Rename DriveProvider to ExternalProvider.

ui/file_manager/file_manager/foreground/js/metadata/metadata_cache.js

 // Copyright (c) 2012 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.
 
 'use strict';
 
 /**
  * MetadataCache is a map from Entry to an object containing properties.
  * Properties are divided by types, and all properties of one type are accessed
  * at once.
  * Some of the properties:
  * {
  *   filesystem: size, modificationTime
  *   internal: presence
- *   drive: pinned, present, hosted, availableOffline
+ *   external: pinned, present, hosted, availableOffline
  *
- *   Following are not fetched for non-present drive files.
+ *   Following are not fetched for non-present external files.
  *   media: artist, album, title, width, height, imageTransform, etc.
  *   thumbnail: url, transform
  *
  *   Following are always fetched from content, and so force the downloading
- *   of remote drive files. One should use this for required content metadata,
+ *   of external files. One should use this for required content metadata,
  *   i.e. image orientation.
  *   fetchedMedia: width, height, etc.
  * }
  *
  * Typical usages:
  * {
- *   cache.get([entry1, entry2], 'drive|filesystem', function(metadata) {
- *     if (metadata[0].drive.pinned && metadata[1].filesystem.size === 0)
+ *   cache.get([entry1, entry2], 'external|filesystem', function(metadata) {
+ *     if (metadata[0].external.pinned && metadata[1].filesystem.size === 0)
  *       alert("Pinned and empty!");
  *   });
  *
  *   cache.set(entry, 'internal', {presence: 'deleted'});
  *
  *   cache.clear([fileEntry1, fileEntry2], 'filesystem');
  *
  *   // Getting fresh value.
  *   cache.clear(entry, 'thumbnail');
  *   cache.getOne(entry, 'thumbnail', function(thumbnail) {
@@ skipping 70 matching lines @@
 /**
  * Margin of the cache size. This amount of caches may be kept in addition.
  */
 MetadataCache.EVICTION_THRESHOLD_MARGIN = 500;
 
 /**
  * @param {VolumeManagerWrapper} volumeManager Volume manager instance.
  * @return {MetadataCache!} The cache with all providers.
  */
 MetadataCache.createFull = function(volumeManager) {
-  // DriveProvider should be prior to FileSystemProvider, because it covers
-  // FileSystemProvider for files in Drive.
+  // ExternalProvider should be prior to FileSystemProvider, because it covers
+  // FileSystemProvider for files on the external backend, eg. Drive.
   return new MetadataCache([
-    new DriveProvider(volumeManager),
+    new ExternalProvider(volumeManager),
     new FilesystemProvider(),
     new ContentProvider()
   ]);
 };
 
 /**
  * Clones metadata entry. Metadata entries may contain scalars, arrays,
  * hash arrays and Date object. Other objects are not supported.
  * @param {Object} metadata Metadata object.
  * @return {Object} Cloned entry.
@@ skipping 616 matching lines @@
         size: (entry.isFile ? (metadata.size || 0) : -1),
         modificationTime: metadata.modificationTime
       }
     });
   }
 
   entry.getMetadata(onMetadata.bind(null, entry), onError);
 };
 
 /**
- * Provider of drive metadata.
+ * Provider of metadata for entries on the external file system backend.
  * This provider returns the following objects:
- *     drive: { pinned, hosted, present, customIconUrl, etc. }
+ *     external: { pinned, hosted, present, customIconUrl, etc. }
  *     thumbnail: { url, transform }
  * @param {VolumeManagerWrapper} volumeManager Volume manager instance.
  * @constructor
  */
-function DriveProvider(volumeManager) {
+function ExternalProvider(volumeManager) {
   MetadataProvider.call(this);
 
   /**
    * @type {VolumeManagerWrapper}
    * @private
    */
   this.volumeManager_ = volumeManager;
 
   // We batch metadata fetches into single API call.
   this.entries_ = [];
   this.callbacks_ = [];
   this.scheduled_ = false;
 
   this.callApiBound_ = this.callApi_.bind(this);
 }
 
-DriveProvider.prototype = {
+ExternalProvider.prototype = {
   __proto__: MetadataProvider.prototype
 };
 
 /**
  * @param {Entry} entry The entry.
  * @return {boolean} Whether this provider supports the entry.
  */
-DriveProvider.prototype.supportsEntry = function(entry) {
+ExternalProvider.prototype.supportsEntry = function(entry) {
   var locationInfo = this.volumeManager_.getLocationInfo(entry);
+  // TODO(mtomasz): Add support for provided file systems.
   return locationInfo && locationInfo.isDriveBased;
 };
 
 /**
  * @param {string} type The metadata type.
  * @return {boolean} Whether this provider provides this metadata.
  */
-DriveProvider.prototype.providesType = function(type) {
-  return type === 'drive' || type === 'thumbnail' ||
+ExternalProvider.prototype.providesType = function(type) {
+  return type === 'external' || type === 'thumbnail' ||
       type === 'media' || type === 'filesystem';
 };
 
 /**
  * @return {string} Unique provider id.
  */
-DriveProvider.prototype.getId = function() { return 'drive'; };
+ExternalProvider.prototype.getId = function() { return 'external'; };
 
 /**
  * Fetches the metadata.
  * @param {Entry} entry File entry.
  * @param {string} type Requested metadata type.
  * @param {function(Object)} callback Callback expects a map from metadata type
  *     to metadata value. This callback is called asynchronously.
  */
-DriveProvider.prototype.fetch = function(entry, type, callback) {
+ExternalProvider.prototype.fetch = function(entry, type, callback) {
   this.entries_.push(entry);
   this.callbacks_.push(callback);
   if (!this.scheduled_) {
     this.scheduled_ = true;
     setTimeout(this.callApiBound_, 0);
   }
 };
 
 /**
  * Schedules the API call.
  * @private
  */
-DriveProvider.prototype.callApi_ = function() {
+ExternalProvider.prototype.callApi_ = function() {
   this.scheduled_ = false;
 
   var entries = this.entries_;
   var callbacks = this.callbacks_;
   this.entries_ = [];
   this.callbacks_ = [];
   var self = this;
 
   // TODO(mtomasz): Make getEntryProperties accept Entry instead of URL.
   var entryURLs = util.entriesToURLs(entries);
   chrome.fileBrowserPrivate.getEntryProperties(
       entryURLs,
       function(propertiesList) {
         console.assert(propertiesList.length === callbacks.length);
         for (var i = 0; i < callbacks.length; i++) {
           callbacks[i](self.convert_(propertiesList[i], entries[i]));
         }
       });
 };
 
 /**
  * Converts API metadata to internal format.
  * @param {Object} data Metadata from API call.
  * @param {Entry} entry File entry.
  * @return {Object} Metadata in internal format.
  * @private
  */
-DriveProvider.prototype.convert_ = function(data, entry) {
+ExternalProvider.prototype.convert_ = function(data, entry) {
   var result = {};
-  result.drive = {
+  result.external = {
     present: data.isPresent,
     pinned: data.isPinned,
     hosted: data.isHosted,
     imageWidth: data.imageWidth,
     imageHeight: data.imageHeight,
     imageRotation: data.imageRotation,
     availableOffline: data.isAvailableOffline,
     availableWhenMetered: data.isAvailableWhenMetered,
     customIconUrl: data.customIconUrl || '',
     contentMimeType: data.contentMimeType || '',
@@ skipping 211 matching lines @@
 
 /**
  * Handles the 'log' message from the worker.
  * @param {Array.<*>} arglist Log arguments.
  * @private
  */
 ContentProvider.prototype.onLog_ = function(arglist) {
   if (MetadataCache.log)  // Avoid log spam by default.
     console.log.apply(console, ['metadata:'].concat(arglist));
 };