The Tor Browser: dom/xslt/tests/buster/buster-view.js@97036ab72558 (annotated)

dom/xslt/tests/buster/buster-view.js@97036ab72558 (annotated)

dom/xslt/tests/buster/buster-view.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: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* 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/. */
 var view =
 {
     onRun : function()
     {
         runQueue.mArray = new Array();
         var sels = this.boxObject.view.selection,a=new Object(),b=new Object(),k;
         var rowResource, name, path;
         for (k=0;k<sels.getRangeCount();k++){
             sels.getRangeAt(k,a,b);
             for (var l=a.value;l<=b.value;l++) {
                 rowResource = this.builder.getResourceAtIndex(l);
                 itemCache.getItem(rowResource);
             }
         }
         runQueue.run();
     },
     displayTest : function()
     {
         var current = this.boxObject.view.selection.currentIndex;
         var rowResource = this.builder.getResourceAtIndex(current);
         var item = itemCache.getItem(rowResource);
     },
     browseForRDF : function()
     {
         var fp = doCreateRDFFP('Xalan Description File',
                                nsIFilePicker.modeOpen);
         var res = fp.show();
         if (res == nsIFilePicker.returnOK) {
             var furl = fp.fileURL;
             this.setDataSource(fp.fileURL.spec);
         }
     },
     dump_Good : function()
     {
         var enumi = this.mResultDS.GetSources(krTypeSucc, kGood, true);
         var k = 0;
         while (enumi.hasMoreElements()) {
             k += 1;
             dump(enumi.getNext().QueryInterface(nsIRDFResource).Value+"\n");
         }
         dump("found "+k+" good tests\n");
     },
     prune_ds : function()
     {
         if (this.mResultDS) {
             this.mResultDS.QueryInterface(nsIRDFPurgeableDataSource).Sweep();
         }
         regressionStats.init()
         itemCache.mArray = new Array();
     },
     setDataSource : function(aSpec)
     {
         var baseSpec;
         if (aSpec) {
             baseSpec = aSpec;
         }
         else {
             baseSpec = document.getElementById("xalan_rdf").value;
         }
         if (this.mXalanDS && this.mXalanDS.URI == baseSpec) {
             this.mXalanDS.QueryInterface(nsIRDFRemoteDataSource);
             this.mXalanDS.Refresh(true);
         }
         else {
             if (this.mXalanDS) {
                 this.database.RemoveDataSource(view.mXalanDS);
             }
             this.mXalanDS = kRDFSvc.GetDataSourceBlocking(baseSpec);
             if (!this.mXalanDS) {
                 alert("Unable do load DataSource: "+baseSpec);
                 return;
             }
             this.database.AddDataSource(this.mXalanDS);
         }
         regressionStats.init();
         if (!this.mResultDS) {
             this.mResultDS = doCreate(kRDFInMemContractID,
                                       nsIRDFDataSource);
             this.database.AddDataSource(view.mResultDS);
             if (!this.mResultDS) {
                 alert("Unable to create result InMemDatasource");
                 return;
             }
         }
         this.builder.rebuild();
         document.getElementById("xalan_rdf").value = baseSpec;
         runItem.prototype.kXalan.init(runItem.prototype.kXalan.URLTYPE_STANDARD,
 , baseSpec, null, null);
     },
     loadHtml : function(aUrl, aListener)
     {
         const nsIIRequestor = Components.interfaces.nsIInterfaceRequestor;
         const nsIWebProgress = Components.interfaces.nsIWebProgress;
         var req = this.mIframe.webNavigation.QueryInterface(nsIIRequestor);
         var prog = req.getInterface(nsIWebProgress);
         prog.addProgressListener(aListener, nsIWebProgress.NOTIFY_ALL);
         this.mIframe.webNavigation.loadURI(aUrl, 0,null,null,null);
     },
     fillItemContext : function()
     {
         var index = view.boxObject.view.selection.currentIndex;
         var res = view.builder.getResourceAtIndex(index);
         var purp = view.mXalanDS.GetTarget(res, krTypePurp, true);
         return (purp != null);
     }
 }
 regressionStats =
 {
     observe: function(aSubject, aTopic, aData)
     {
         if (aTopic != 'success') {
             return;
         }
         var arc = (aData == "true") ? krTypeSuccCount : krTypeFailCount;
         this.assertNewCount(aSubject, arc, 1);
     },
     init: function()
     {
         if (this.mRegressionDS) {
             this.mRegressionDS.QueryInterface(nsIRDFPurgeableDataSource).Sweep();
         }
         else {
             this.mRegressionDS =
                 doCreate(kRDFInMemContractID, nsIRDFDataSource);
             view.database.AddDataSource(this.mRegressionDS);
         }
     },
     getParent: function(aDS, aSource)
     {
         // parent chached?
         var parent = this.mRegressionDS.GetTarget(aSource, krTypeParent, true);
         if (!parent) {
             var labels = view.mXalanDS.ArcLabelsIn(aSource);
             while (labels.hasMoreElements()) {
                 var arc = labels.getNext().QueryInterface(nsIRDFResource);
                 if (arc.Value.match(this.mChildRE)) {
                     parent = view.mXalanDS.GetSource(arc, aSource, true);
                     // cache the parent
                     this.mRegressionDS.Assert(aSource, krTypeParent,
                                               parent, true);
                 }
             }
         }
         return parent;
     },
     assertNewCount: function(aSource, aArc, aIncrement)
     {
         var root = kRDFSvc.GetResource('urn:root');
         var count = 0;
         // parent chached?
         var parent = this.getParent(view.XalanDS, aSource);
         while (parent && !parent.EqualsNode(root)) {
             var countRes = view.mResultDS.GetTarget(parent, aArc, true);
             if (countRes) {
                 count = countRes.QueryInterface(nsIRDFInt).Value;
             }
             var newCountRes = kRDFSvc.GetIntLiteral(count + aIncrement);
             if (!newCountRes) {
                 return;
             }
             if (countRes) {
                 view.mResultDS.Change(parent, aArc, countRes, newCountRes);
             }
             else {
                 view.mResultDS.Assert(parent, aArc, newCountRes, true);
             }
             parent = this.getParent(view.XalanDS, parent);
         }
     },
     mRegressionDS: 0,
     mChildRE: /http:\/\/www\.w3\.org\/1999\/02\/22-rdf-syntax-ns#_/
 }
 function rdfObserve(aSubject, aTopic, aData)
 {
     if (aTopic == "success") {
         var target = (aData == "true") ? kGood : kBad;
         view.mResultDS.Assert(aSubject, krTypeSucc, target, true);
         regressionStats.observe(aSubject, aTopic, aData);
     }
 }
 runItem.prototype.kObservers.push(rdfObserve);