Change ImageLoaderClient to return width and height of image.

ui/file_manager/image_loader/cache.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.
 
 /**
  * Persistent cache storing images in an indexed database on the hard disk.
  * @constructor
  */
 function Cache() {
   /**
    * IndexedDB database handle.
    * @type {IDBDatabase}
    * @private
    */
   this.db_ = null;
 }
 
 /**
  * Cache database name.
  * @type {string}
  * @const
  */
 Cache.DB_NAME = 'image-loader';
 
 /**
  * Cache database version.
  * @type {number}
  * @const
  */
-Cache.DB_VERSION = 11;
+Cache.DB_VERSION = 12;
 
 /**
  * Memory limit for images data in bytes.
  *
  * @const
  * @type {number}
  */
 Cache.MEMORY_LIMIT = 250 * 1024 * 1024;  // 250 MB.
 
 /**
@@ skipping 167 matching lines @@
   }.bind(this);
 
   this.fetchCacheSize_(onCacheSize, onFailure, transaction);
 };
 
 /**
  * Saves an image in the cache.
  *
  * @param {string} key Cache key.
  * @param {string} data Image data.
+ * @param {number} width Image width.
+ * @param {number} height Image height.
  * @param {number} timestamp Last modification timestamp. Used to detect
  *     if the cache entry becomes out of date.
  */
-Cache.prototype.saveImage = function(key, data, timestamp) {
+Cache.prototype.saveImage = function(key, data, width, height, timestamp) {
   if (!this.db_) {
     console.warn('Cache database not available.');
     return;
   }
 
   var onNotFoundInCache = function() {
     var metadataEntry = {
       key: key,
       timestamp: timestamp,
+      width: width,
+      height: height,
       size: data.length,
       lastLoadTimestamp: Date.now()};
     var dataEntry = {key: key, data: data};
 
     var transaction = this.db_.transaction(['settings', 'metadata', 'data'],
                                            'readwrite');
     var metadataStore = transaction.objectStore('metadata');
     var dataStore = transaction.objectStore('data');
 
     var onCacheEvicted = function() {
       metadataStore.put(metadataEntry);  // Add asynchronously.
       dataStore.put(dataEntry);  // Add asynchronously.
     };
 
     // Make sure there is enough space in the cache.
     this.evictCache_(data.length, onCacheEvicted, function() {}, transaction);
   }.bind(this);
 
   // Check if the image is already in cache. If not, then save it to cache.
   this.loadImage(key, timestamp, function() {}, onNotFoundInCache);
 };
 
 /**
  * Loads an image from the cache (if available) or returns null.
  *
  * @param {string} key Cache key.
  * @param {number} timestamp Last modification timestamp. If different
  *     that the one in cache, then the entry will be invalidated.
- * @param {function(string)} onSuccess Success callback with the image's data.
+ * @param {function(string, number, number)} onSuccess Success callback with
+ *     the image's data, width, height.
  * @param {function()} onFailure Failure callback.
  */
 Cache.prototype.loadImage = function(key, timestamp, onSuccess, onFailure) {
   if (!this.db_) {
     console.warn('Cache database not available.');
     onFailure();
     return;
   }
 
   var transaction = this.db_.transaction(['settings', 'metadata', 'data'],
@@ skipping 26 matching lines @@
       onFailure();
     } else if (metadataEntry.timestamp != timestamp) {
       // The image is not up to date, so remove it.
       this.removeImage(key, function() {}, function() {}, transaction);
       onFailure();
     } else {
       // The image is available. Update the last load time and return the
       // image data.
       metadataEntry.lastLoadTimestamp = Date.now();
       metadataStore.put(metadataEntry);  // Added asynchronously.
-      onSuccess(dataEntry.data);
+      onSuccess(dataEntry.data, metadataEntry.width, metadataEntry.height);
     }
   }.bind(this);
 
   metadataRequest.onsuccess = function(e) {
     if (e.target.result)
       metadataEntry = e.target.result;
     metadataReceived = true;
     onPartialSuccess();
   };
 
@@ skipping 85 matching lines @@
     metadataReceived = true;
     onPartialSuccess();
   };
 
   metadataRequest.onerror = function() {
     console.error('Failed to remove an image.');
     metadataReceived = true;
     onPartialSuccess();
   };
 };