image/test/unit/async_load_tests.js

   1 /*
   2  * Test to ensure that image loading/decoding notifications are always
   3  * delivered async, and in the order we expect.
   4  *
   5  * Must be included from a file that has a uri of the image to test defined in
   6  * var uri.
   7  */
   8 /* import-globals-from image_load_helpers.js */
   9
  10 const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
  11 const { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
  12 const ReferrerInfo = Components.Constructor(
  13   "@mozilla.org/referrer-info;1",
  14   "nsIReferrerInfo",
  15   "init"
  16 );
  17
  18 var server = new HttpServer();
  19 server.registerDirectory("/", do_get_file(""));
  20 server.registerContentType("sjs", "sjs");
  21 server.start(-1);
  22
  23 load("image_load_helpers.js");
  24
  25 var requests = [];
  26 /* global uri */
  27
  28 // Return a closure that holds on to the listener from the original
  29 // imgIRequest, and compares its results to the cloned one.
  30 function getCloneStopCallback(original_listener) {
  31   return function cloneStop(listener) {
  32     Assert.equal(original_listener.state, listener.state);
  33
  34     // Sanity check to make sure we didn't accidentally use the same listener
  35     // twice.
  36     Assert.notEqual(original_listener, listener);
  37     do_test_finished();
  38   };
  39 }
  40
  41 // Make sure that cloned requests get all the same callbacks as the original,
  42 // but they aren't synchronous right now.
  43 function checkClone(other_listener, aRequest) {
  44   do_test_pending();
  45
  46   // For as long as clone notification is synchronous, we can't test the clone state reliably.
  47   var listener = new ImageListener(
  48     null,
  49     function(foo, bar) {
  50       do_test_finished();
  51     } /* getCloneStopCallback(other_listener)*/
  52   );
  53   listener.synchronous = false;
  54   var outer = Cc["@mozilla.org/image/tools;1"]
  55     .getService(Ci.imgITools)
  56     .createScriptedObserver(listener);
  57   var clone = aRequest.clone(outer);
  58   requests.push({ request: clone, locked: false });
  59 }
  60
  61 // Ensure that all the callbacks were called on aRequest.
  62 function checkSizeAndLoad(listener, aRequest) {
  63   Assert.notEqual(listener.state & SIZE_AVAILABLE, 0);
  64   Assert.notEqual(listener.state & LOAD_COMPLETE, 0);
  65
  66   do_test_finished();
  67 }
  68
  69 function secondLoadDone(oldlistener, aRequest) {
  70   do_test_pending();
  71
  72   try {
  73     var staticrequest = aRequest.getStaticRequest();
  74
  75     // For as long as clone notification is synchronous, we can't test the
  76     // clone state reliably.
  77     var listener = new ImageListener(null, checkSizeAndLoad);
  78     listener.synchronous = false;
  79     var outer = Cc["@mozilla.org/image/tools;1"]
  80       .getService(Ci.imgITools)
  81       .createScriptedObserver(listener);
  82     var staticrequestclone = staticrequest.clone(outer);
  83     requests.push({ request: staticrequestclone, locked: false });
  84   } catch (e) {
  85     // We can't create a static request. Most likely the request we started
  86     // with didn't load successfully.
  87     do_test_finished();
  88   }
  89
  90   run_loadImageWithChannel_tests();
  91
  92   do_test_finished();
  93 }
  94
  95 // Load the request a second time. This should come from the image cache, and
  96 // therefore would be at most risk of being served synchronously.
  97 function checkSecondLoad() {
  98   do_test_pending();
  99
 100   var listener = new ImageListener(checkClone, secondLoadDone);
 101   var outer = Cc["@mozilla.org/image/tools;1"]
 102     .getService(Ci.imgITools)
 103     .createScriptedObserver(listener);
 104   var referrerInfo = new ReferrerInfo(
 105     Ci.nsIReferrerInfo.NO_REFERRER_WHEN_DOWNGRADE,
 106     true,
 107     null
 108   );
 109   requests.push({
 110     request: gCurrentLoader.loadImageXPCOM(
 111       uri,
 112       null,
 113       referrerInfo,
 114       null,
 115       null,
 116       outer,
 117       null,
 118       0,
 119       null
 120     ),
 121     locked: false,
 122   });
 123   listener.synchronous = false;
 124 }
 125
 126 function firstLoadDone(oldlistener, aRequest) {
 127   checkSecondLoad(uri);
 128
 129   do_test_finished();
 130 }
 131
 132 // Return a closure that allows us to check the stream listener's status when the
 133 // image finishes loading.
 134 function getChannelLoadImageStopCallback(streamlistener, next) {
 135   return function channelLoadStop(imglistener, aRequest) {
 136     next();
 137
 138     do_test_finished();
 139   };
 140 }
 141
 142 // Load the request a second time. This should come from the image cache, and
 143 // therefore would be at most risk of being served synchronously.
 144 function checkSecondChannelLoad() {
 145   do_test_pending();
 146   var channel = NetUtil.newChannel({ uri, loadUsingSystemPrincipal: true });
 147   var channellistener = new ChannelListener();
 148   channel.asyncOpen(channellistener);
 149
 150   var listener = new ImageListener(
 151     null,
 152     getChannelLoadImageStopCallback(channellistener, all_done_callback)
 153   );
 154   var outer = Cc["@mozilla.org/image/tools;1"]
 155     .getService(Ci.imgITools)
 156     .createScriptedObserver(listener);
 157   var outlistener = {};
 158   requests.push({
 159     request: gCurrentLoader.loadImageWithChannelXPCOM(
 160       channel,
 161       outer,
 162       null,
 163       outlistener
 164     ),
 165     locked: false,
 166   });
 167   channellistener.outputListener = outlistener.value;
 168
 169   listener.synchronous = false;
 170 }
 171
 172 function run_loadImageWithChannel_tests() {
 173   // To ensure we're testing what we expect to, create a new loader and cache.
 174   gCurrentLoader = Cc["@mozilla.org/image/loader;1"].createInstance(
 175     Ci.imgILoader
 176   );
 177
 178   do_test_pending();
 179   var channel = NetUtil.newChannel({ uri, loadUsingSystemPrincipal: true });
 180   var channellistener = new ChannelListener();
 181   channel.asyncOpen(channellistener);
 182
 183   var listener = new ImageListener(
 184     null,
 185     getChannelLoadImageStopCallback(channellistener, checkSecondChannelLoad)
 186   );
 187   var outer = Cc["@mozilla.org/image/tools;1"]
 188     .getService(Ci.imgITools)
 189     .createScriptedObserver(listener);
 190   var outlistener = {};
 191   requests.push({
 192     request: gCurrentLoader.loadImageWithChannelXPCOM(
 193       channel,
 194       outer,
 195       null,
 196       outlistener
 197     ),
 198     locked: false,
 199   });
 200   channellistener.outputListener = outlistener.value;
 201
 202   listener.synchronous = false;
 203 }
 204
 205 function all_done_callback() {
 206   server.stop(function() {
 207     do_test_finished();
 208   });
 209 }
 210
 211 function startImageCallback(otherCb) {
 212   return function(listener, request) {
 213     // Make sure we can load the same image immediately out of the cache.
 214     do_test_pending();
 215     var listener2 = new ImageListener(null, function(foo, bar) {
 216       do_test_finished();
 217     });
 218     var outer = Cc["@mozilla.org/image/tools;1"]
 219       .getService(Ci.imgITools)
 220       .createScriptedObserver(listener2);
 221     var referrerInfo = new ReferrerInfo(
 222       Ci.nsIReferrerInfo.NO_REFERRER_WHEN_DOWNGRADE,
 223       true,
 224       null
 225     );
 226     requests.push({
 227       request: gCurrentLoader.loadImageXPCOM(
 228         uri,
 229         null,
 230         referrerInfo,
 231         null,
 232         null,
 233         outer,
 234         null,
 235         0,
 236         null
 237       ),
 238       locked: false,
 239     });
 240     listener2.synchronous = false;
 241
 242     // Now that we've started another load, chain to the callback.
 243     otherCb(listener, request);
 244   };
 245 }
 246
 247 var gCurrentLoader;
 248
 249 function cleanup() {
 250   for (let { request, locked } of requests) {
 251     if (locked) {
 252       try {
 253         request.unlockImage();
 254       } catch (e) {}
 255     }
 256     request.cancelAndForgetObserver(0);
 257   }
 258 }
 259
 260 function run_test() {
 261   registerCleanupFunction(cleanup);
 262
 263   gCurrentLoader = Cc["@mozilla.org/image/loader;1"].createInstance(
 264     Ci.imgILoader
 265   );
 266
 267   do_test_pending();
 268   var listener = new ImageListener(
 269     startImageCallback(checkClone),
 270     firstLoadDone
 271   );
 272   var outer = Cc["@mozilla.org/image/tools;1"]
 273     .getService(Ci.imgITools)
 274     .createScriptedObserver(listener);
 275   var referrerInfo = new ReferrerInfo(
 276     Ci.nsIReferrerInfo.NO_REFERRER_WHEN_DOWNGRADE,
 277     true,
 278     null
 279   );
 280   var req = gCurrentLoader.loadImageXPCOM(
 281     uri,
 282     null,
 283     referrerInfo,
 284     null,
 285     null,
 286     outer,
 287     null,
 288     0,
 289     null
 290   );
 291
 292   // Ensure that we don't cause any mayhem when we lock an image.
 293   req.lockImage();
 294
 295   requests.push({ request: req, locked: true });
 296
 297   listener.synchronous = false;
 298 }