The Tor Browser: netwerk/test/TestAsyncCache.js@6474c204b198 (annotated)

netwerk/test/TestAsyncCache.js@6474c204b198 (annotated)

netwerk/test/TestAsyncCache.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 var DEBUG = true;
 var clientID = "javascript";
 var nsICache = Components.interfaces.nsICache;
 function getEventQueue()
 {
     var nsIEventQueueService = Components.interfaces.nsIEventQueueService;
     var CID = Components.classes["@mozilla.org/event-queue-service;1"];
     var service = CID.getService(nsIEventQueueService);
     return service.getSpecialEventQueue(nsIEventQueueService.CURRENT_THREAD_EVENT_QUEUE);
 }
 var eventQueue = getEventQueue();
 function getCacheService()
 {
     var nsCacheService = Components.classes["@mozilla.org/network/cache-service;1"];
     var service = nsCacheService.getService(Components.interfaces.nsICacheService);
     return service;
 }
 function createCacheSession(clientID, storagePolicy, streamable)
 {
     var service = getCacheService();
     var session = service.createSession(clientID, storagePolicy, streamable);
     return session;
 }
 function openCacheEntry(url, mode)
 {
     var session = createCacheSession(clientID, nsICache.STORE_ON_DISK, true);
     var entry = session.openCacheEntry(url, mode);
     return entry;
 }
 function wrapInputStream(input)
 {
     var nsIScriptableInputStream = Components.interfaces.nsIScriptableInputStream;
     var factory = Components.classes["@mozilla.org/scriptableinputstream;1"];
     var wrapper = factory.createInstance(nsIScriptableInputStream);
     wrapper.init(input);
     return wrapper;
 }
 function download(url)
 {
     var data = "";
     var buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 65536);
     var stream = url.getContent();
     while (true) {
         var count = stream.read(buffer);
         if (count <= 0)
             break;
         var str = new java.lang.String(buffer, 0, count);
         data += str;
     }
     stream.close();
     return data;
 }
 function write(url, data)
 {
     var key = url.toString();
     var outputEntry = openCacheEntry(key, nsICache.ACCESS_WRITE);
     var output = outputEntry.transport.openOutputStream(0, -1, 0);
     var count = output.write(data, data.length);
     // store some metadata.
     outputEntry.setMetaDataElement("size", data.length);
     output.close();
     outputEntry.markValid();
     outputEntry.close();
     return count;
 }
 function CacheListener()
 {
     this.done = false;
 }
 CacheListener.prototype = {
     QueryInterface : function(iid)
     {
         if (iid.equals(Components.interfaces.nsICacheListener))
             return this;
         throw Components.results.NS_NOINTERFACE;
     },
     onCacheEntryAvailable : function(/* in nsICacheEntryDescriptor */   descriptor,
                                      /* in nsCacheAccessMode */         accessGranted,
                                      /* in nsresult */                  status)
     {
         this.descriptor = descriptor;
         this.status = status;
         this.done = true;
     }
 };
 function asyncOpenCacheEntry(url, mode)
 {
     var session = createCacheSession(clientID, nsICache.STORE_ON_DISK, true);
     var listener = new CacheListener();
     session.asyncOpenCacheEntry(url, mode, listener);
     while (!listener.done)
         eventQueue.processPendingEvents();
     return listener.descriptor;
 }
 function asyncWrite(key, data)
 {
     var outputEntry = asyncOpenCacheEntry(key, nsICache.ACCESS_WRITE);
     var output = outputEntry.transport.openOutputStream(0, -1, 0);
     var count = output.write(data, data.length);
     // store some metadata.
     outputEntry.setMetaDataElement("size", data.length);
     output.close();
     outputEntry.markValid();
     outputEntry.close();
     return count;
 }
 function StreamListener()
 {
     this.done = false;
     this.data = "";
     this.wrapper = null;
 }
 StreamListener.prototype = {
     QueryInterface : function(iid)
     {
         if (iid.equals(Components.interfaces.nsIStreamListener) ||
             iid.equals(Components.interfaces.nsIStreamObserver))
             return this;
         throw Components.results.NS_NOINTERFACE;
     },
     onStartRequest : function(request, context)
     {
     },
     onStopRequest : function(request, context, statusCode, statusText)
     {
         this.statusCode = statusCode;
         this.done = true;
     },
     onDataAvailable : function(request, context, input, offset, count)
     {
         if (this.wrapper == null)
             this.wrapper = wrapInputStream(input);
         input = this.wrapper;
         this.data += input.read(count);
     }
 };
 function asyncRead(key)
 {
     var inputEntry = asyncOpenCacheEntry(key, nsICache.ACCESS_READ);
     var listener = new StreamListener();
     inputEntry.transport.asyncRead(listener, null, 0, inputEntry.dataSize, 0);
     while (!listener.done)
         eventQueue.processPendingEvents();
     inputEntry.close();
     return listener.data;
 }
 function read(key)
 {
     var inputEntry = openCacheEntry(key, nsICache.ACCESS_READ);
     var input = wrapInputStream(inputEntry.transport.openInputStream(0, -1, 0));
     var data = input.read(input.available());
     input.close();
     inputEntry.close();
     return data;
 }
 function readMetaData(key, element)
 {
     var inputEntry = openCacheEntry(key, nsICache.ACCESS_READ);
     var metadata = inputEntry.getMetaDataElement(element);
     inputEntry.close();
     return metadata;
 }
 function doom(url)
 {
     var key = url.toString();
     var doomedEntry = openCacheEntry(key, nsICache.ACCESS_READ_WRITE);
     doomedEntry.doom();
     doomedEntry.close();
 }
 function test()
 {
     // download some real content from the network.
     var url = new java.net.URL("http://www.mozilla.org");
     var key = url.toString();
     var data = download(url);
     if (asyncWrite(key, data) == data.length)
         print("disk cache write works!");
     else
         print("disk cache write broken!");
     if (asyncRead(key) == data)
         print("disk cache read works!");
     else
         print("disk cache read broken!");
     if (readMetaData(key, "size") == data.length)
         print("disk cache metadata works!");
     else
         print("disk cache metadata broken!");
 }
 function median(array)
 {
     var cmp = function(x, y) { return x - y; }
     array.sort(cmp);
     var middle = Math.floor(array.length / 2);
     return array[middle];
 }
 function sum(array)
 {
     var s = 0;
     var len = array.length;
     for (var i = 0; i < len; ++i)
         s += array[i];
     return s;
 }
 function time()
 {
     var N = 50;
     var System = java.lang.System;
     var url = new java.net.URL("http://www.mozilla.org");
     var key = url.toString();
     var downloadTimes = new Array();
     for (var i = 0; i < N; ++i) {
         var begin = System.currentTimeMillis();
         download(url);
         var end = System.currentTimeMillis();
         downloadTimes.push(end - begin);
     }
     var downloadTotal = sum(downloadTimes);
     var downloadMean = downloadTotal / N;
     var downloadMedian = median(downloadTimes);
     print("" + N + " downloads took " + downloadTotal + " milliseconds.");
     print("mean = " + downloadMean + " milliseconds.");
     print("median = " + downloadMedian + " milliseconds.");
     var readTimes = new Array();
     for (var i = 0; i < N; ++i) {
         var begin = System.currentTimeMillis();
         asyncRead(key);
         var end = System.currentTimeMillis();
         readTimes.push(end - begin);
     }
     var readTotal = sum(readTimes);
     var readMean = readTotal / N;
     var readMedian = median(readTimes);
     print("" + N + " reads took " + readTotal + " milliseconds.");
     print("mean = " + readMean + " milliseconds.");
     print("median = " + readMedian + " milliseconds.");
 }
 // load the cache service before doing anything with Java...
 getCacheService();
 if (DEBUG) {
     print("cache service loaded.");
 } else {
     print("running disk cache test.");
     test();
     print("disk cache test complete.");
 }