Fix all compiler errors found by the new compiler version.

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() {
+function ImageCache() {
   /**
    * IndexedDB database handle.
    * @type {IDBDatabase}
    * @private
    */
   this.db_ = null;
 }
 
 /**
  * Cache database name.
  * @type {string}
  * @const
  */
-Cache.DB_NAME = 'image-loader';
+ImageCache.DB_NAME = 'image-loader';
 
 /**
  * Cache database version.
  * @type {number}
  * @const
  */
-Cache.DB_VERSION = 12;
+ImageCache.DB_VERSION = 12;
 
 /**
  * Memory limit for images data in bytes.
  *
  * @const
  * @type {number}
  */
-Cache.MEMORY_LIMIT = 250 * 1024 * 1024;  // 250 MB.
+ImageCache.MEMORY_LIMIT = 250 * 1024 * 1024;  // 250 MB.
 
 /**
  * Minimal amount of memory freed per eviction. Used to limit number of
  * evictions which are expensive.
  *
  * @const
  * @type {number}
  */
-Cache.EVICTION_CHUNK_SIZE = 50 * 1024 * 1024;  // 50 MB.
+ImageCache.EVICTION_CHUNK_SIZE = 50 * 1024 * 1024;  // 50 MB.
 
 /**
  * Creates a cache key.
  *
  * @param {Object} request Request options.
  * @return {?string} Cache key. It may be null if the cache does not support
  *     |request|. e.g. Data URI.
  */
-Cache.createKey = function(request) {
+ImageCache.createKey = function(request) {
   if (/^data:/i.test(request.url))
     return null;
   return JSON.stringify({
     url: request.url,
     scale: request.scale,
     width: request.width,
     height: request.height,
     maxWidth: request.maxWidth,
     maxHeight: request.maxHeight});
 };
 
 /**
  * Initializes the cache database.
  * @param {function()} callback Completion callback.
  */
-Cache.prototype.initialize = function(callback) {
+ImageCache.prototype.initialize = function(callback) {
   // Establish a connection to the database or (re)create it if not available
   // or not up to date. After changing the database's schema, increment
-  // Cache.DB_VERSION to force database recreating.
-  var openRequest = window.indexedDB.open(Cache.DB_NAME, Cache.DB_VERSION);
+  // ImageCache.DB_VERSION to force database recreating.
+  var openRequest = window.indexedDB.open(
+      ImageCache.DB_NAME, ImageCache.DB_VERSION);
 
   openRequest.onsuccess = function(e) {
     this.db_ = e.target.result;
     callback();
   }.bind(this);
 
   openRequest.onerror = callback;
 
   openRequest.onupgradeneeded = function(e) {
     console.info('Cache database creating or upgrading.');
@@ skipping 11 matching lines @@
 };
 
 /**
  * Sets size of the cache.
  *
  * @param {number} size Size in bytes.
  * @param {IDBTransaction=} opt_transaction Transaction to be reused. If not
  *     provided, then a new one is created.
  * @private
  */
-Cache.prototype.setCacheSize_ = function(size, opt_transaction) {
+ImageCache.prototype.setCacheSize_ = function(size, opt_transaction) {
   var transaction = opt_transaction ||
       this.db_.transaction(['settings'], 'readwrite');
   var settingsStore = transaction.objectStore('settings');
 
   settingsStore.put({key: 'size', value: size});  // Update asynchronously.
 };
 
 /**
  * Fetches current size of the cache.
  *
  * @param {function(number)} onSuccess Callback to return the size.
  * @param {function()} onFailure Failure callback.
  * @param {IDBTransaction=} opt_transaction Transaction to be reused. If not
  *     provided, then a new one is created.
  * @private
  */
-Cache.prototype.fetchCacheSize_ = function(
+ImageCache.prototype.fetchCacheSize_ = function(
     onSuccess, onFailure, opt_transaction) {
   var transaction = opt_transaction ||
       this.db_.transaction(['settings', 'metadata', 'data'], 'readwrite');
   var settingsStore = transaction.objectStore('settings');
   var sizeRequest = settingsStore.get('size');
 
   sizeRequest.onsuccess = function(e) {
     if (e.target.result)
       onSuccess(e.target.result.value);
     else
@@ skipping 10 matching lines @@
  * Evicts the least used elements in cache to make space for a new image and
  * updates size of the cache taking into account the upcoming item.
  *
  * @param {number} size Requested size.
  * @param {function()} onSuccess Success callback.
  * @param {function()} onFailure Failure callback.
  * @param {IDBTransaction=} opt_transaction Transaction to be reused. If not
  *     provided, then a new one is created.
  * @private
  */
-Cache.prototype.evictCache_ = function(
+ImageCache.prototype.evictCache_ = function(
     size, onSuccess, onFailure, opt_transaction) {
   var transaction = opt_transaction ||
       this.db_.transaction(['settings', 'metadata', 'data'], 'readwrite');
 
   // Check if the requested size is smaller than the cache size.
-  if (size > Cache.MEMORY_LIMIT) {
+  if (size > ImageCache.MEMORY_LIMIT) {
     onFailure();
     return;
   }
 
   var onCacheSize = function(cacheSize) {
-    if (size < Cache.MEMORY_LIMIT - cacheSize) {
+    if (size < ImageCache.MEMORY_LIMIT - cacheSize) {
       // Enough space, no need to evict.
       this.setCacheSize_(cacheSize + size, transaction);
       onSuccess();
       return;
     }
 
-    var bytesToEvict = Math.max(size, Cache.EVICTION_CHUNK_SIZE);
+    var bytesToEvict = Math.max(size, ImageCache.EVICTION_CHUNK_SIZE);
 
     // Fetch all metadata.
     var metadataEntries = [];
     var metadataStore = transaction.objectStore('metadata');
     var dataStore = transaction.objectStore('data');
 
     var onEntriesFetched = function() {
       metadataEntries.sort(function(a, b) {
         return b.lastLoadTimestamp - a.lastLoadTimestamp;
       });
@@ skipping 27 matching lines @@
 /**
  * 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, width, height, timestamp) {
+ImageCache.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,
@@ skipping 23 matching lines @@
 /**
  * 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, 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) {
+ImageCache.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'],
                                          'readwrite');
   var metadataStore = transaction.objectStore('metadata');
   var dataStore = transaction.objectStore('data');
@@ skipping 63 matching lines @@
 
 /**
  * Removes the image from the cache.
  *
  * @param {string} key Cache key.
  * @param {function()=} opt_onSuccess Success callback.
  * @param {function()=} opt_onFailure Failure callback.
  * @param {IDBTransaction=} opt_transaction Transaction to be reused. If not
  *     provided, then a new one is created.
  */
-Cache.prototype.removeImage = function(
+ImageCache.prototype.removeImage = function(
     key, opt_onSuccess, opt_onFailure, opt_transaction) {
   if (!this.db_) {
     console.warn('Cache database not available.');
     return;
   }
 
   var transaction = opt_transaction ||
       this.db_.transaction(['settings', 'metadata', 'data'], 'readwrite');
   var metadataStore = transaction.objectStore('metadata');
   var dataStore = transaction.objectStore('data');
@@ skipping 45 matching lines @@
     metadataReceived = true;
     onPartialSuccess();
   };
 
   metadataRequest.onerror = function() {
     console.error('Failed to remove an image.');
     metadataReceived = true;
     onPartialSuccess();
   };
 };