Fix all compiler errors found by the new compiler version.

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),
  *   url: string,
  *   orientation: ImageOrientation,
  *   colorSpace: ?ColorSpace
  * }}
  */
 var LoadImageRequest;
 
 /**
  * Creates and starts downloading and then resizing of the image. Finally,
  * returns the image using the callback.
  *
  * @param {string} id Request ID.
- * @param {Cache} cache Cache object.
+ * @param {ImageCache} cache Cache object.
  * @param {!PiexLoader} piexLoader Piex loader for RAW file.
  * @param {LoadImageRequest} request Request message as a hash array.
  * @param {function(Object)} callback Callback used to send the response.
  * @constructor
  */
-function Request(id, cache, piexLoader, request, callback) {
+function ImageRequest(id, cache, piexLoader, request, callback) {
   /**
    * @type {string}
    * @private
    */
   this.id_ = id;
 
   /**
-   * @type {Cache}
+   * @type {ImageCache}
    * @private
    */
   this.cache_ = cache;
 
   /**
    * @type {!PiexLoader}
    * @private
    */
   this.piexLoader_ = piexLoader;
 
@@ skipping 50 matching lines @@
    * @type {?function()}
    * @private
    */
   this.downloadCallback_ = null;
 }
 
 /**
  * Returns ID of the request.
  * @return {string} Request ID.
  */
-Request.prototype.getId = function() {
+ImageRequest.prototype.getId = function() {
   return this.id_;
 };
 
 /**
  * Returns priority of the request. The higher priority, the faster it will
  * be handled. The highest priority is 0. The default one is 2.
  *
  * @return {number} Priority.
  */
-Request.prototype.getPriority = function() {
+ImageRequest.prototype.getPriority = function() {
   return (this.request_.priority !== undefined) ? this.request_.priority : 2;
 };
 
 /**
  * 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) {
+ImageRequest.prototype.loadFromCacheAndProcess = function(
+    onSuccess, onFailure) {
   this.loadFromCache_(
       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) {
+ImageRequest.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, number, number)} onSuccess Success callback.
  * @param {function()} onFailure Failure callback.
  * @private
  */
-Request.prototype.loadFromCache_ = function(onSuccess, onFailure) {
-  var cacheKey = Cache.createKey(this.request_);
+ImageRequest.prototype.loadFromCache_ = function(onSuccess, onFailure) {
+  var cacheKey = ImageCache.createKey(this.request_);
 
   if (!cacheKey) {
     // Cache key is not provided for the request.
     onFailure();
     return;
   }
 
   if (!this.request_.cache) {
     // Cache is disabled for this request; therefore, remove it from cache
     // if existed.
@@ skipping 15 matching lines @@
 };
 
 /**
  * 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, width, height) {
+ImageRequest.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_);
+  var cacheKey = ImageCache.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
  */
-Request.prototype.downloadOriginal_ = function(onSuccess, onFailure) {
+ImageRequest.prototype.downloadOriginal_ = function(onSuccess, onFailure) {
   this.image_.onload = function() {
     URL.revokeObjectURL(this.image_.src);
     onSuccess();
   }.bind(this);
   this.image_.onerror = function() {
     URL.revokeObjectURL(this.image_.src);
     onFailure();
   }.bind(this);
 
   // Download data urls directly since they are not supported by XmlHttpRequest.
@@ skipping 189 matching lines @@
   return xhr;
 };
 
 /**
  * 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) {
+ImageRequest.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 {
@@ skipping 20 matching lines @@
   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, width, height) {
+ImageRequest.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() {
+ImageRequest.prototype.onImageLoad_ = function() {
   // Perform processing if the url is not a data url, or if there are some
   // operations requested.
   if (!this.request_.url.match(/^data/) ||
       ImageLoader.shouldProcess(this.image_.width,
                                 this.image_.height,
                                 this.request_)) {
     ImageLoader.resizeAndCrop(this.image_, this.canvas_, this.request_);
     ImageLoader.convertColorSpace(
         this.canvas_, this.request_.colorSpace || ColorSpace.SRGB);
     this.sendImage_(true);  // Image changed.
   } else {
     this.sendImage_(false);  // Image not changed.
   }
   this.cleanup_();
   this.downloadCallback_();
 };
 
 /**
  * Handler, when loading of the image fails. Sends a failure response and
  * finalizes the request process.
  * @private
  */
-Request.prototype.onImageError_ = function() {
+ImageRequest.prototype.onImageError_ = function() {
   this.sendResponse_(
       {status: 'error', taskId: this.request_.taskId});
   this.cleanup_();
   this.downloadCallback_();
 };
 
 /**
  * Cancels the request.
  */
-Request.prototype.cancel = function() {
+ImageRequest.prototype.cancel = function() {
   this.cleanup_();
 
   // If downloading has started, then call the callback.
   if (this.downloadCallback_)
     this.downloadCallback_();
 };
 
 /**
  * Cleans up memory used by this request.
  * @private
  */
-Request.prototype.cleanup_ = function() {
+ImageRequest.prototype.cleanup_ = function() {
   this.image_.onerror = function() {};
   this.image_.onload = function() {};
 
   // Transparent 1x1 pixel gif, to force garbage collecting.
   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;
 };