Simplify volume manager in Files app.

chrome/browser/resources/file_manager/background/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.
  *
  * @param {util.VolumeType} volumeType The type of the volume.
  * @param {string} volumeId ID of the volume.
- * @param {DirectoryEntry} root The root directory entry of this volume.
+ * @param {DOMFileSystem} fileSystem The file system object for this volume.
  * @param {string} error The error if an error is found.
  * @param {string} deviceType The type of device ('usb'|'sd'|'optical'|'mobile'
  *     |'unknown') (as defined in chromeos/disks/disk_mount_manager.cc).
  *     Can be null.
  * @param {boolean} isReadOnly True if the volume is read only.
  * @param {!{displayName:string, isCurrentProfile:boolean}} profile Profile
  *     information.
  * @param {string} label Label of the volume.
  * @constructor
  */
 function VolumeInfo(
     volumeType,
     volumeId,
-    root,
+    fileSystem,
     error,
     deviceType,
     isReadOnly,
     profile,
     label) {
   this.volumeType_ = volumeType;
-  // TODO(hidehiko): This should include FileSystem instance.
   this.volumeId_ = volumeId;
-  this.root_ = root;
+  this.fileSystem_ = fileSystem;
   this.label_ = label;
   this.displayRoot_ = null;
   this.fakeEntries_ = {};
   this.displayRoot_ = null;
   this.displayRootPromise_ = null;
 
   if (volumeType === util.VolumeType.DRIVE) {
     // TODO(mtomasz): Convert fake entries to DirectoryProvider.
     this.fakeEntries_[RootType.DRIVE_OFFLINE] = {
       isDirectory: true,
@@ skipping 24 matching lines @@
 }
 
 VolumeInfo.prototype = {
   /**
    * @return {util.VolumeType} Volume type.
    */
   get volumeType() {
     return this.volumeType_;
   },
   /**
-   * @return {string} Volume id.
+   * @return {string} Volume ID.
    */
   get volumeId() {
     return this.volumeId_;
   },
   /**
-   * @return {DirectoryEntry} Root path.
+   * @return {DOMFileSystem} File system object.
    */
-  get root() {
-    return this.root_;
+  get fileSystem() {
+    return this.fileSystem_;
   },
   /**
    * @return {DirectoryEntry} Display root path. It is null before finishing to
    * resolve the entry.
    */
   get displayRoot() {
     return this.displayRoot_;
   },
   /**
    * @return {Object.<string, Object>} Fake entries.
@@ skipping 39 matching lines @@
  *
  * @param {function(DirectoryEntry)} onSuccess Success callback with the
  *     display root directory as an argument.
  * @param {function(FileError)} onFailure Failure callback.
  */
 VolumeInfo.prototype.resolveDisplayRoot = function(onSuccess, onFailure) {
   if (!this.displayRootPromise_) {
     // TODO(mtomasz): Do not add VolumeInfo which failed to resolve root, and
     // remove this if logic. Call onSuccess() always, instead.
     if (this.volumeType !== util.VolumeType.DRIVE) {
-      if (this.root)
-        this.displayRootPromise_ = Promise.resolve(this.root);
+      if (this.fileSystem_)
+        this.displayRootPromise_ = Promise.resolve(this.fileSystem_.root);
       else
         this.displayRootPromise_ = Promise.reject(this.error);
     } else {
       // For Drive, we need to resolve.
-      var displayRootURL = this.root.toURL() + '/root';
+      var displayRootURL = this.fileSystem_.root.toURL() + '/root';
       this.displayRootPromise_ = new Promise(
           webkitResolveLocalFileSystemURL.bind(null, displayRootURL));
     }
 
     // Store the obtained displayRoot.
     this.displayRootPromise_.then(function(displayRoot) {
       this.displayRoot_ = displayRoot;
     }.bind(this));
   }
   this.displayRootPromise_.then(onSuccess, onFailure);
@@ skipping 11 matching lines @@
 volumeManagerUtil.validateError = function(error) {
   for (var key in util.VolumeError) {
     if (error === util.VolumeError[key])
       return;
   }
 
   throw new Error('Invalid mount error: ' + error);
 };
 
 /**
- * Returns the root entry of a volume mounted at mountPath.
- * TODO(mtomasz): Remove this method.
- *
- * @param {string} volumeId ID of the volume to be mounted.
- * @param {function(DirectoryEntry)} successCallback Called when the root entry
- *     is found.
- * @param {function(FileError)} errorCallback Called when an error is found.
- * @private
- */
-volumeManagerUtil.getRootEntry_ = function(
-    volumeId, successCallback, errorCallback) {
-  // We always request FileSystem here, because requestFileSystem() grants
-  // permissions if necessary, especially for Drive File System at first mount
-  // time.
-  // Note that we actually need to request FileSystem after multi file system
-  // support, so this will be more natural code then.
-  chrome.fileBrowserPrivate.requestFileSystem(
-      volumeId,
-      function(fileSystem) {
-        // TODO(hidehiko): chrome.runtime.lastError should have error reason.
-        if (!fileSystem) {
-          errorCallback(util.createDOMError(util.FileError.NOT_FOUND_ERR));
-          return;
-        }
-
-        successCallback(fileSystem.root);
-      });
-};
-
-/**
  * Builds the VolumeInfo data from VolumeMetadata.
  * @param {VolumeMetadata} volumeMetadata Metadata instance for the volume.
  * @param {function(VolumeInfo)} callback Called on completion.
  */
 volumeManagerUtil.createVolumeInfo = function(volumeMetadata, callback) {
   var localizedLabel;
   switch (volumeMetadata.volumeType) {
     case util.VolumeType.DOWNLOADS:
       localizedLabel = str('DOWNLOADS_DIRECTORY_LABEL');
       break;
     case util.VolumeType.DRIVE:
       localizedLabel = str('DRIVE_DIRECTORY_LABEL');
       break;
     default:
       localizedLabel = volumeMetadata.volumeId.split(':', 2)[1];
       break;
   }
-  volumeManagerUtil.getRootEntry_(
+
+  chrome.fileBrowserPrivate.requestFileSystem(
       volumeMetadata.volumeId,
-      function(entry) {
+      function(fileSystem) {
+        // TODO(mtomasz): chrome.runtime.lastError should have error reason.
+        if (!fileSystem) {
+          console.error('File system not found: ' + volumeMetadata.volumeId);
+          callback(new VolumeInfo(
+              volumeMetadata.volumeType,
+              volumeMetadata.volumeId,
+              null,  // File system is not found.
+              volumeMetadata.mountCondition,
+              volumeMetadata.deviceType,
+              volumeMetadata.isReadOnly,
+              volumeMetadata.profile,
+              localizedLabel));
+          return;
+        }
         if (volumeMetadata.volumeType === util.VolumeType.DRIVE) {
           // After file system is mounted, we "read" drive grand root
           // entry at first. This triggers full feed fetch on background.
           // Note: we don't need to handle errors here, because even if
           // it fails, accessing to some path later will just become
           // a fast-fetch and it re-triggers full-feed fetch.
-          entry.createReader().readEntries(
+          fileSystem.root.createReader().readEntries(
               function() { /* do nothing */ },
               function(error) {
                 console.error(
                     'Triggering full feed fetch is failed: ' + error.name);
               });
         }
         callback(new VolumeInfo(
             volumeMetadata.volumeType,
             volumeMetadata.volumeId,
-            entry,
+            fileSystem,
             volumeMetadata.mountCondition,
             volumeMetadata.deviceType,
             volumeMetadata.isReadOnly,
-            volumeMetadata.profile,
-            localizedLabel));
-      },
-      function(fileError) {
-        console.error('Root entry is not found: ' +
-            volumeMetadata.mountPath + ', ' + fileError.name);
-        callback(new VolumeInfo(
-            volumeMetadata.volumeType,
-            volumeMetadata.volumeId,
-            null,  // Root entry is not found.
-            volumeMetadata.mountCondition,
-            volumeMetadata.deviceType,
-            volumeMetadata.isReadOnly,
             volumeMetadata.profile,
             localizedLabel));
       });
 };
 
 /**
  * The order of the volume list based on root type.
  * @type {Array.<util.VolumeType>}
  * @const
  * @private
@@ skipping 106 matching lines @@
   }
   return -1;
 };
 
 /**
  * Searches the information of the volume that contains the passed entry.
  * @param {Entry|Object} entry Entry on the volume to be foudn.
  * @return {VolumeInfo} The volume's information, or null if not found.
  */
 VolumeInfoList.prototype.findByEntry = function(entry) {
-  // TODO(mtomasz): Switch to comparing file systems once possible.
   for (var i = 0; i < this.length; i++) {
     var volumeInfo = this.item(i);
-    if (!volumeInfo.root)
-      continue;
-    // URL of the root always contains the trailing slash.
-    if (util.isSameEntry(entry, volumeInfo.root) ||
-        entry.toURL().indexOf(volumeInfo.root.toURL()) === 0) {
+    if (volumeInfo.fileSystem &&
+        util.isSameFileSystem(volumeInfo.fileSystem, entry.filesystem)) {
       return volumeInfo;
     }
     // Additionally, check fake entries.
     for (var key in volumeInfo.fakeEntries_) {
       var fakeEntry = volumeInfo.fakeEntries_[key];
       if (util.isSameEntry(fakeEntry, entry))
         return volumeInfo;
     }
   }
   return null;
@@ skipping 266 matching lines @@
   return null;
 };
 
 /**
  * Obtains location information from an entry.
  *
  * @param {Entry|Object} entry File or directory entry. It can be a fake entry.
  * @return {EntryLocation} Location information.
  */
 VolumeManager.prototype.getLocationInfo = function(entry) {
+  var volumeInfo = this.volumeInfoList.findByEntry(entry);
+  if (!volumeInfo)
+    return null;
+
   if (util.isFakeEntry(entry)) {
     return new EntryLocation(
-        // TODO(hirono): Specify currect volume.
-        this.getCurrentProfileVolumeInfo(RootType.DRIVE),
+        volumeInfo,
         entry.rootType,
         true /* the entry points a root directory. */,
         true /* fake entries are read only. */);
   }
 
-  var volumeInfo = this.volumeInfoList.findByEntry(entry);
-  if (!volumeInfo)
-    return null;
-
   var rootType;
   var isReadOnly;
   var isRootEntry;
   if (volumeInfo.volumeType === util.VolumeType.DRIVE) {
     // For Drive, the roots are /root and /other, instead of /. Root URLs
     // contain trailing slashes.
-    // TODO(mtomasz): Simplify once switching to filesystem per volume.
-    if (entry.toURL() === volumeInfo.root.toURL() + 'root' ||
-        entry.toURL().indexOf(volumeInfo.root.toURL() + 'root/') === 0) {
+    if (entry.fullPath == '/root' || entry.fullPath.indexOf('/root/') === 0) {
       rootType = RootType.DRIVE;
       isReadOnly = volumeInfo.isReadOnly;
-      isRootEntry = entry.toURL() === volumeInfo.root.toURL() + 'root';
-    } else if (entry.toURL() === volumeInfo.root.toURL() + 'other' ||
-        entry.toURL().indexOf(volumeInfo.root.toURL() + 'other/') === 0) {
+      isRootEntry = entry.fullPath === '/root';
+    } else if (entry.fullPath == '/other' ||
+               entry.fullPath.indexOf('/other/') === 0) {
       rootType = RootType.DRIVE_OTHER;
       isReadOnly = true;
-      isRootEntry = entry.toURL() === volumeInfo.root.toURL() + 'other';
+      isRootEntry = entry.fullPath === '/other';
     } else {
       // Accessing Drive files outside of /drive/root and /drive/other is not
       // allowed, but can happen. Therefore returning null.
       return null;
     }
   } else {
     // Otherwise, root path is same with a mount path of the volume.
     switch (volumeInfo.volumeType) {
       case util.VolumeType.DOWNLOADS:
         rootType = RootType.DOWNLOADS;
         break;
       case util.VolumeType.REMOVABLE:
         rootType = RootType.REMOVABLE;
         break;
       case util.VolumeType.ARCHIVE:
         rootType = RootType.ARCHIVE;
         break;
       case util.VolumeType.CLOUD_DEVICE:
         rootType = RootType.CLOUD_DEVICE;
         break;
       default:
         // Programming error, throw an exception.
         throw new Error('Invalid volume type: ' + volumeInfo.volumeType);
     }
     isReadOnly = volumeInfo.isReadOnly;
-    isRootEntry = util.isSameEntry(entry, volumeInfo.root);
+    isRootEntry = util.isSameEntry(entry, volumeInfo.fileSystem.root);
   }
 
   return new EntryLocation(volumeInfo, rootType, isRootEntry, isReadOnly);
 };
 
 /**
  * @param {string} key Key produced by |makeRequestKey_|.
  * @param {function(VolumeInfo)} successCallback To be called when request
  *     finishes successfully.
  * @param {function(util.VolumeError)} errorCallback To be called when
@@ skipping 127 matching lines @@
       this.isDriveBased;
 
   /**
    * Whether the entry is read only or not.
    * @type {boolean}
    */
   this.isReadOnly = isReadOnly;
 
   Object.freeze(this);
 }