Change ImageLoaderClient to return width and height of image.

ui/file_manager/image_loader/request.js

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @typedef {{
  *   cache: (boolean|undefined),
  *   priority: (number|undefined),
  *   taskId: number,
  *   timestamp: (number|undefined),
@@ skipping 100 matching lines @@
 };
 
 /**
  * Tries to load the image from cache if exists and sends the response.
  *
  * @param {function()} onSuccess Success callback.
  * @param {function()} onFailure Failure callback.
  */
 Request.prototype.loadFromCacheAndProcess = function(onSuccess, onFailure) {
   this.loadFromCache_(
-      function(data) {  // Found in cache.
-        this.sendImageData_(data);
+      function(data, width, height) {  // Found in cache.
+        this.sendImageData_(data, width, height);
         onSuccess();
       }.bind(this),
       onFailure);  // Not found in cache.
 };
 
 /**
  * Tries to download the image, resizes and sends the response.
  * @param {function()} callback Completion callback.
  */
 Request.prototype.downloadAndProcess = function(callback) {
   if (this.downloadCallback_)
     throw new Error('Downloading already started.');
 
   this.downloadCallback_ = callback;
   this.downloadOriginal_(this.onImageLoad_.bind(this),
                          this.onImageError_.bind(this));
 };
 
 /**
  * Fetches the image from the persistent cache.
  *
- * @param {function(string)} onSuccess Success callback.
+ * @param {function(string, number, number)} onSuccess Success callback.
  * @param {function()} onFailure Failure callback.
  * @private
  */
 Request.prototype.loadFromCache_ = function(onSuccess, onFailure) {
   var cacheKey = Cache.createKey(this.request_);
 
   if (!cacheKey) {
     // Cache key is not provided for the request.
     onFailure();
     return;
@@ skipping 16 matching lines @@
   this.cache_.loadImage(cacheKey,
                         this.request_.timestamp,
                         onSuccess,
                         onFailure);
 };
 
 /**
  * Saves the image to the persistent cache.
  *
  * @param {string} data The image's data.
+ * @param {number} width Image width.
+ * @param {number} height Image height.
  * @private
  */
-Request.prototype.saveToCache_ = function(data) {
+Request.prototype.saveToCache_ = function(data, width, height) {
   if (!this.request_.cache || !this.request_.timestamp) {
     // Persistent cache is available only when a timestamp is provided.
     return;
   }
 
   var cacheKey = Cache.createKey(this.request_);
   if (!cacheKey) {
     // Cache key is not provided for the request.
     return;
   }
 
   this.cache_.saveImage(cacheKey,
                         data,
+                        width,
+                        height,
                         this.request_.timestamp);
 };
 
 /**
  * Downloads an image directly or for remote resources using the XmlHttpRequest.
  *
  * @param {function()} onSuccess Success callback.
  * @param {function()} onFailure Failure callback.
  * @private
  */
@@ skipping 150 matching lines @@
 
 /**
  * Sends the resized image via the callback. If the image has been changed,
  * then packs the canvas contents, otherwise sends the raw image data.
  *
  * @param {boolean} imageChanged Whether the image has been changed.
  * @private
  */
 Request.prototype.sendImage_ = function(imageChanged) {
   var imageData;
+  var width;
+  var height;
   if (!imageChanged) {
     // The image hasn't been processed, so the raw data can be directly
     // forwarded for speed (no need to encode the image again).
     imageData = this.image_.src;
+    width = this.image_.width;
+    height = this.image_.height;
   } else {
     // The image has been resized or rotated, therefore the canvas has to be
     // encoded to get the correct compressed image data.
+    width = this.canvas_.width;
+    height = this.canvas_.height;
+
     switch (this.contentType_) {
       case 'image/gif':
       case 'image/png':
       case 'image/svg':
       case 'image/bmp':
         imageData = this.canvas_.toDataURL('image/png');
         break;
       case 'image/jpeg':
       default:
         imageData = this.canvas_.toDataURL('image/jpeg', 0.9);
     }
   }
 
   // Send and store in the persistent cache.
-  this.sendImageData_(imageData);
-  this.saveToCache_(imageData);
+  this.sendImageData_(imageData, width, height);
+  this.saveToCache_(imageData, width, height);
 };
 
 /**
  * Sends the resized image via the callback.
  * @param {string} data Compressed image data.
+ * @param {number} width Width.
+ * @param {number} height Height.
  * @private
  */
-Request.prototype.sendImageData_ = function(data) {
-  this.sendResponse_(
-      {status: 'success', data: data, taskId: this.request_.taskId});
+Request.prototype.sendImageData_ = function(data, width, height) {
+  this.sendResponse_({
+    status: 'success', data: data, width: width, height: height,
+    taskId: this.request_.taskId
+  });
 };
 
 /**
  * Handler, when contents are loaded into the image element. Performs resizing
  * and finalizes the request process.
  * @private
  */
 Request.prototype.onImageLoad_ = function() {
   // Perform processing if the url is not a data url, or if there are some
   // operations requested.
@@ skipping 45 matching lines @@
   this.image_.src = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAA' +
       'ABAAEAAAICTAEAOw==';
 
   this.xhr_.onload = function() {};
   this.xhr_.abort();
 
   // Dispose memory allocated by Canvas.
   this.canvas_.width = 0;
   this.canvas_.height = 0;
 };