Replace mountType by volumeType on fileBrowserPrivate APIs.

chrome/browser/resources/file_manager/js/volume_manager.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';
 
 /**
  * Represents each volume, such as "drive", "download directory", each "USB
  * flush storage", or "mounted zip archive" etc.
  *
@@ skipping 496 matching lines @@
     // about Drive, Downloads nor archives.
     // TODO(hidehiko): Figure out the historical intention of the method,
     // and clean them up.
 
     // Create VolumeInfo for each mount point.
     var group = new AsyncUtil.Group();
     for (var i = 0; i < mountPointList.length; i++) {
       var mountPoint = mountPointList[i];
 
       // TODO(hidehiko): It should be ok that the drive is mounted already.
-      if (mountPoint.mountType == 'drive')
+      if (mountPoint.volumeType == 'drive')
         console.error('Drive is not expected initially mounted');
 
       var error = mountPoint.mountCondition ?
           'error_' + mountPoint.mountCondition : '';
       group.add(function(mountPoint, error, callback) {
         volumeManagerUtil.createVolumeInfo(
             '/' + mountPoint.mountPath, error,
             function(volumeInfo) {
               this.volumeInfoList.add(volumeInfo);
               callback();
@@ skipping 27 matching lines @@
 
 /**
  * Event handler called when some volume was mounted or unmouted.
  * @param {MountCompletedEvent} event Received event.
  * @private
  */
 VolumeManager.prototype.onMountCompleted_ = function(event) {
   if (event.eventType == 'mount') {
     if (event.mountPath) {
       var requestKey = this.makeRequestKey_(
-          'mount', event.mountType, event.sourcePath);
+          'mount', event.volumeType, event.sourcePath);
       var error = event.status == 'success' ? '' : event.status;
       volumeManagerUtil.createVolumeInfo(
           event.mountPath, error, function(volume) {
             this.volumeInfoList.add(volume);
             this.finishRequest_(requestKey, event.status, event.mountPath);
             cr.dispatchSimpleEvent(this, 'change');
           }.bind(this));
     } else {
       console.warn('No mount path.');
       this.finishRequest_(requestKey, event.status);
@@ skipping 16 matching lines @@
       this.dispatchEvent(e);
     }
     this.finishRequest_(requestKey, status);
 
     if (event.status == 'success') {
       this.volumeInfoList.remove(mountPath);
       cr.dispatchSimpleEvent(this, 'change');
     }
   }
 
-  if (event.mountType == 'drive') {
+  if (event.volumeType == 'drive') {
     if (event.status == 'success') {
       if (event.eventType == 'mount') {
         // If the mount is not requested, the mount status will not be changed
         // at mountDrive(). Sets it here in such a case.
         var self = this;
         var timeout = setTimeout(function() {
           if (self.getDriveStatus() == VolumeManager.DriveStatus.UNMOUNTED)
             self.setDriveStatus_(VolumeManager.DriveStatus.MOUNTING);
           timeout = null;
         }, VolumeManager.MOUNTING_DELAY);
@@ skipping 37 matching lines @@
         entry.createReader().readEntries(
             callback.bind(null, true),
             callback.bind(null, false));
       },
       callback.bind(null, false));
 };
 
 /**
  * Creates string to match mount events with requests.
  * @param {string} requestType 'mount' | 'unmount'.
- * @param {string} mountType 'device' | 'file' | 'network' | 'drive'.
+ * @param {string} volumeType 'drive' | 'downloads' | 'removable' | 'archive'.
  * @param {string} mountOrSourcePath Source path provided by API after
  *     resolving mount request or mountPath for unmount request.
  * @return {string} Key for |this.requests_|.
  * @private
  */
 VolumeManager.prototype.makeRequestKey_ = function(requestType,
-                                                   mountType,
+                                                   volumeType,
                                                    mountOrSourcePath) {
-  return requestType + ':' + mountType + ':' + mountOrSourcePath;
+  return requestType + ':' + volumeType + ':' + mountOrSourcePath;
 };
 
 
 /**
  * @param {function(string)} successCallback Success callback.
  * @param {function(VolumeManager.Error)} errorCallback Error callback.
  */
 VolumeManager.prototype.mountDrive = function(successCallback, errorCallback) {
   if (this.getDriveStatus() == VolumeManager.DriveStatus.ERROR) {
     this.setDriveStatus_(VolumeManager.DriveStatus.UNMOUNTED);
@@ skipping 15 matching lines @@
   });
 };
 
 /**
  * @param {string} fileUrl File url to the archive file.
  * @param {function(string)} successCallback Success callback.
  * @param {function(VolumeManager.Error)} errorCallback Error callback.
  */
 VolumeManager.prototype.mountArchive = function(fileUrl, successCallback,
                                                 errorCallback) {
-  this.mount_(fileUrl, 'file', successCallback, errorCallback);
+  this.mount_(fileUrl, 'archive', successCallback, errorCallback);
 };
 
 /**
  * Unmounts volume.
  * @param {string} mountPath Volume mounted path.
  * @param {function(string)} successCallback Success callback.
  * @param {function(VolumeManager.Error)} errorCallback Error callback.
  */
 VolumeManager.prototype.unmount = function(mountPath,
                                            successCallback,
@@ skipping 20 matching lines @@
  * @param {string} mountPath Volume mounted path.
  * @return {VolumeInfo} The data about the volume.
  */
 VolumeManager.prototype.getVolumeInfo = function(mountPath) {
   volumeManagerUtil.validateMountPath(mountPath);
   return this.volumeInfoList.find(mountPath);
 };
 
 /**
  * @param {string} url URL for for |fileBrowserPrivate.addMount|.
- * @param {'drive'|'file'} mountType Mount type for
+ * @param {'drive'|'archive'} volumeType Volume type for
  *     |fileBrowserPrivate.addMount|.
  * @param {function(string)} successCallback Success callback.
  * @param {function(VolumeManager.Error)} errorCallback Error callback.
  * @private
  */
-VolumeManager.prototype.mount_ = function(url, mountType,
+VolumeManager.prototype.mount_ = function(url, volumeType,
                                           successCallback, errorCallback) {
   if (this.deferredQueue_) {
     this.deferredQueue_.push(this.mount_.bind(this,
-        url, mountType, successCallback, errorCallback));
+        url, volumeType, successCallback, errorCallback));
     return;
   }
 
-  chrome.fileBrowserPrivate.addMount(url, mountType, {},
+  chrome.fileBrowserPrivate.addMount(url, volumeType, {},
                                      function(sourcePath) {
-    console.info('Mount request: url=' + url + '; mountType=' + mountType +
+    console.info('Mount request: url=' + url + '; volumeType=' + volumeType +
                  '; sourceUrl=' + sourcePath);
-    var requestKey = this.makeRequestKey_('mount', mountType, sourcePath);
+    var requestKey = this.makeRequestKey_('mount', volumeType, sourcePath);
     this.startRequest_(requestKey, successCallback, errorCallback);
   }.bind(this));
 };
 
 /**
  * @param {string} key Key produced by |makeRequestKey_|.
  * @param {function(string)} successCallback To be called when request finishes
  *     successfully.
  * @param {function(VolumeManager.Error)} errorCallback To be called when
  *     request fails.
@@ skipping 57 matching lines @@
       callbacks[i].apply(self, args);
     }
   };
   if (status == 'success') {
     callEach(request.successCallbacks, this, [opt_mountPath]);
   } else {
     volumeManagerUtil.validateError(status);
     callEach(request.errorCallbacks, this, [status]);
   }
 };