The Tor Browser: content/test/unit/head_content.js@97036ab72558 (annotated)

content/test/unit/head_content.js@97036ab72558 (annotated)

content/test/unit/head_content.js

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 const I                    = Components.interfaces;
 const C                    = Components.classes;
 const nsILocalFile         = I.nsILocalFile;
 const nsIProperties        = I.nsIProperties;
 const nsIFileInputStream   = I.nsIFileInputStream;
 const nsIInputStream       = I.nsIInputStream;
 const nsIDOMParser         = I.nsIDOMParser;
 const nsIDOMSerializer     = I.nsIDOMSerializer;
 const nsIDOMDocument       = I.nsIDOMDocument;
 const nsIDOMElement        = I.nsIDOMElement;
 const nsIDOMNode           = I.nsIDOMNode;
 const nsIDOMCharacterData  = I.nsIDOMCharacterData;
 const nsIDOMAttr           = I.nsIDOMAttr;
 const nsIDOMNodeList       = I.nsIDOMNodeList;
 const nsIDOMXULElement     = I.nsIDOMXULElement;
 const nsIDOMProcessingInstruction = I.nsIDOMProcessingInstruction;
 function DOMParser() {
   var parser = C["@mozilla.org/xmlextras/domparser;1"].createInstance(nsIDOMParser);
   parser.init();
   return parser;
 }
 var __testsDirectory = null;
 function ParseFile(file) {
   if (typeof(file) == "string") {
     if (!__testsDirectory) {
       __testsDirectory = do_get_cwd();
     }
     var fileObj = __testsDirectory.clone();
     fileObj.append(file);
     file = fileObj;
   }
   do_check_eq(file instanceof nsILocalFile, true);
   var fileStr = C["@mozilla.org/network/file-input-stream;1"]
                  .createInstance(nsIFileInputStream);
   // Init for readonly reading
   fileStr.init(file,  0x01, 0400, nsIFileInputStream.CLOSE_ON_EOF);
   return ParseXML(fileStr);
 }
 function ParseXML(data) {
   if (typeof(data) == "string") {
     return DOMParser().parseFromString(data, "application/xml");
   }
   do_check_eq(data instanceof nsIInputStream, true);
   return DOMParser().parseFromStream(data, "UTF-8", data.available(),
                                      "application/xml");
 }
 function DOMSerializer() {
   return C["@mozilla.org/xmlextras/xmlserializer;1"]
           .createInstance(nsIDOMSerializer);
 }
 function SerializeXML(node) {
   return DOMSerializer().serializeToString(node);
 }
 function roundtrip(obj) {
   if (typeof(obj) == "string") {
     return SerializeXML(ParseXML(obj));
   }
   do_check_eq(obj instanceof nsIDOMNode, true);
   return ParseXML(SerializeXML(obj));
 }
 function do_compare_attrs(e1, e2) {
   const xmlns = "http://www.w3.org/2000/xmlns/";
   var a1 = e1.attributes;
   var a2 = e2.attributes;
   for (var i = 0; i < a1.length; ++i) {
     var att = a1.item(i);
     // Don't test for namespace decls, since those can just sorta be
     // scattered about
     if (att.namespaceURI != xmlns) {
       var att2 = a2.getNamedItemNS(att.namespaceURI, att.localName);
       if (!att2) {
         do_throw("Missing attribute with namespaceURI '" + att.namespaceURI +
                  "' and localName '" + att.localName + "'");
       }
       do_check_eq(att.QueryInterface(nsIDOMAttr).value,
                   att2.QueryInterface(nsIDOMAttr).value);
     }
   }
 }
 function do_check_equiv(dom1, dom2) {
   do_check_eq(dom1.nodeType, dom2.nodeType);
   // There's no classinfo around, so we'll need to do some QIing to
   // make sure the right interfaces are flattened as needed.
   switch (dom1.nodeType) {
   case nsIDOMNode.PROCESSING_INSTRUCTION_NODE:
     do_check_eq(dom1.QueryInterface(nsIDOMProcessingInstruction).target,
                 dom2.QueryInterface(nsIDOMProcessingInstruction).target);
     do_check_eq(dom1.data, dom2.data);
   case nsIDOMNode.TEXT_NODE:
   case nsIDOMNode.CDATA_SECTION_NODE:
   case nsIDOMNode.COMMENT_NODE:
     do_check_eq(dom1.QueryInterface(nsIDOMCharacterData).data,
                 dom2.QueryInterface(nsIDOMCharacterData).data);
     break;
   case nsIDOMNode.ELEMENT_NODE:
     do_check_eq(dom1.namespaceURI, dom2.namespaceURI);
     do_check_eq(dom1.localName, dom2.localName);
     // Compare attrs in both directions -- do_compare_attrs does a
     // subset check.
     do_compare_attrs(dom1, dom2);
     do_compare_attrs(dom2, dom1);
     // Fall through
   case nsIDOMNode.DOCUMENT_NODE:
     do_check_eq(dom1.childNodes.length, dom2.childNodes.length);
     for (var i = 0; i < dom1.childNodes.length; ++i) {
       do_check_equiv(dom1.childNodes.item(i), dom2.childNodes.item(i));
     }
     break;
   }
 }
 function do_check_serialize(dom) {
   do_check_equiv(dom, roundtrip(dom));
 }
 function Pipe() {
   var p = C["@mozilla.org/pipe;1"].createInstance(I.nsIPipe);
   p.init(false, false, 0, 0xffffffff, null);
   return p;
 }
 function ScriptableInput(arg) {
   if (arg instanceof I.nsIPipe) {
     arg = arg.inputStream;
   }
   var str = C["@mozilla.org/scriptableinputstream;1"].
     createInstance(I.nsIScriptableInputStream);
   str.init(arg);
   return str;
 }