The Tor Browser / file comparison

comparison: netwerk/test/TestAsyncCache.js

netwerk/test/TestAsyncCache.js

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:9e2dacbeaa24
1 var DEBUG = true;
2
3 var clientID = "javascript";
4 var nsICache = Components.interfaces.nsICache;
5
6 function getEventQueue()
7 {
8 var nsIEventQueueService = Components.interfaces.nsIEventQueueService;
9 var CID = Components.classes["@mozilla.org/event-queue-service;1"];
10 var service = CID.getService(nsIEventQueueService);
11 return service.getSpecialEventQueue(nsIEventQueueService.CURRENT_THREAD_EVENT_QUEUE);
12 }
13
14 var eventQueue = getEventQueue();
15
16 function getCacheService()
17 {
18 var nsCacheService = Components.classes["@mozilla.org/network/cache-service;1"];
19 var service = nsCacheService.getService(Components.interfaces.nsICacheService);
20 return service;
21 }
22
23 function createCacheSession(clientID, storagePolicy, streamable)
24 {
25 var service = getCacheService();
26 var session = service.createSession(clientID, storagePolicy, streamable);
27 return session;
28 }
29
30 function openCacheEntry(url, mode)
31 {
32 var session = createCacheSession(clientID, nsICache.STORE_ON_DISK, true);
33 var entry = session.openCacheEntry(url, mode);
34 return entry;
35 }
36
37 function wrapInputStream(input)
38 {
39 var nsIScriptableInputStream = Components.interfaces.nsIScriptableInputStream;
40 var factory = Components.classes["@mozilla.org/scriptableinputstream;1"];
41 var wrapper = factory.createInstance(nsIScriptableInputStream);
42 wrapper.init(input);
43 return wrapper;
44 }
45
46 function download(url)
47 {
48 var data = "";
49 var buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 65536);
50 var stream = url.getContent();
51 while (true) {
52 var count = stream.read(buffer);
53 if (count <= 0)
54 break;
55 var str = new java.lang.String(buffer, 0, count);
56 data += str;
57 }
58 stream.close();
59 return data;
60 }
61
62 function write(url, data)
63 {
64 var key = url.toString();
65 var outputEntry = openCacheEntry(key, nsICache.ACCESS_WRITE);
66 var output = outputEntry.transport.openOutputStream(0, -1, 0);
67 var count = output.write(data, data.length);
68
69 // store some metadata.
70 outputEntry.setMetaDataElement("size", data.length);
71
72 output.close();
73 outputEntry.markValid();
74 outputEntry.close();
75
76 return count;
77 }
78
79 function CacheListener()
80 {
81 this.done = false;
82 }
83
84 CacheListener.prototype = {
85 QueryInterface : function(iid)
86 {
87 if (iid.equals(Components.interfaces.nsICacheListener))
88 return this;
89 throw Components.results.NS_NOINTERFACE;
90 },
91
92 onCacheEntryAvailable : function(/* in nsICacheEntryDescriptor */ descriptor,
93 /* in nsCacheAccessMode */ accessGranted,
94 /* in nsresult */ status)
95 {
96 this.descriptor = descriptor;
97 this.status = status;
98 this.done = true;
99 }
100 };
101
102 function asyncOpenCacheEntry(url, mode)
103 {
104 var session = createCacheSession(clientID, nsICache.STORE_ON_DISK, true);
105 var listener = new CacheListener();
106 session.asyncOpenCacheEntry(url, mode, listener);
107 while (!listener.done)
108 eventQueue.processPendingEvents();
109 return listener.descriptor;
110 }
111
112 function asyncWrite(key, data)
113 {
114 var outputEntry = asyncOpenCacheEntry(key, nsICache.ACCESS_WRITE);
115
116 var output = outputEntry.transport.openOutputStream(0, -1, 0);
117 var count = output.write(data, data.length);
118
119 // store some metadata.
120 outputEntry.setMetaDataElement("size", data.length);
121
122 output.close();
123 outputEntry.markValid();
124 outputEntry.close();
125
126 return count;
127 }
128
129 function StreamListener()
130 {
131 this.done = false;
132 this.data = "";
133 this.wrapper = null;
134 }
135
136 StreamListener.prototype = {
137 QueryInterface : function(iid)
138 {
139 if (iid.equals(Components.interfaces.nsIStreamListener) ||
140 iid.equals(Components.interfaces.nsIStreamObserver))
141 return this;
142 throw Components.results.NS_NOINTERFACE;
143 },
144
145 onStartRequest : function(request, context)
146 {
147 },
148
149 onStopRequest : function(request, context, statusCode, statusText)
150 {
151 this.statusCode = statusCode;
152 this.done = true;
153 },
154
155 onDataAvailable : function(request, context, input, offset, count)
156 {
157 if (this.wrapper == null)
158 this.wrapper = wrapInputStream(input);
159 input = this.wrapper;
160 this.data += input.read(count);
161 }
162 };
163
164 function asyncRead(key)
165 {
166 var inputEntry = asyncOpenCacheEntry(key, nsICache.ACCESS_READ);
167 var listener = new StreamListener();
168 inputEntry.transport.asyncRead(listener, null, 0, inputEntry.dataSize, 0);
169 while (!listener.done)
170 eventQueue.processPendingEvents();
171 inputEntry.close();
172 return listener.data;
173 }
174
175 function read(key)
176 {
177 var inputEntry = openCacheEntry(key, nsICache.ACCESS_READ);
178 var input = wrapInputStream(inputEntry.transport.openInputStream(0, -1, 0));
179 var data = input.read(input.available());
180 input.close();
181 inputEntry.close();
182 return data;
183 }
184
185 function readMetaData(key, element)
186 {
187 var inputEntry = openCacheEntry(key, nsICache.ACCESS_READ);
188 var metadata = inputEntry.getMetaDataElement(element);
189 inputEntry.close();
190 return metadata;
191 }
192
193 function doom(url)
194 {
195 var key = url.toString();
196 var doomedEntry = openCacheEntry(key, nsICache.ACCESS_READ_WRITE);
197 doomedEntry.doom();
198 doomedEntry.close();
199 }
200
201 function test()
202 {
203 // download some real content from the network.
204 var url = new java.net.URL("http://www.mozilla.org");
205 var key = url.toString();
206 var data = download(url);
207
208 if (asyncWrite(key, data) == data.length)
209 print("disk cache write works!");
210 else
211 print("disk cache write broken!");
212
213 if (asyncRead(key) == data)
214 print("disk cache read works!");
215 else
216 print("disk cache read broken!");
217
218 if (readMetaData(key, "size") == data.length)
219 print("disk cache metadata works!");
220 else
221 print("disk cache metadata broken!");
222 }
223
224 function median(array)
225 {
226 var cmp = function(x, y) { return x - y; }
227 array.sort(cmp);
228 var middle = Math.floor(array.length / 2);
229 return array[middle];
230 }
231
232 function sum(array)
233 {
234 var s = 0;
235 var len = array.length;
236 for (var i = 0; i < len; ++i)
237 s += array[i];
238 return s;
239 }
240
241 function time()
242 {
243 var N = 50;
244 var System = java.lang.System;
245 var url = new java.net.URL("http://www.mozilla.org");
246 var key = url.toString();
247 var downloadTimes = new Array();
248 for (var i = 0; i < N; ++i) {
249 var begin = System.currentTimeMillis();
250 download(url);
251 var end = System.currentTimeMillis();
252 downloadTimes.push(end - begin);
253 }
254 var downloadTotal = sum(downloadTimes);
255 var downloadMean = downloadTotal / N;
256 var downloadMedian = median(downloadTimes);
257 print("" + N + " downloads took " + downloadTotal + " milliseconds.");
258 print("mean = " + downloadMean + " milliseconds.");
259 print("median = " + downloadMedian + " milliseconds.");
260
261 var readTimes = new Array();
262 for (var i = 0; i < N; ++i) {
263 var begin = System.currentTimeMillis();
264 asyncRead(key);
265 var end = System.currentTimeMillis();
266 readTimes.push(end - begin);
267 }
268 var readTotal = sum(readTimes);
269 var readMean = readTotal / N;
270 var readMedian = median(readTimes);
271 print("" + N + " reads took " + readTotal + " milliseconds.");
272 print("mean = " + readMean + " milliseconds.");
273 print("median = " + readMedian + " milliseconds.");
274 }
275
276 // load the cache service before doing anything with Java...
277 getCacheService();
278
279 if (DEBUG) {
280 print("cache service loaded.");
281 } else {
282 print("running disk cache test.");
283 test();
284 print("disk cache test complete.");
285 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial