Files: Extract VolumeInfo interface from volume_manager.js.

ui/file_manager/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.
 
 /**
  * Represents each volume, such as "drive", "download directory", each "USB
  * flush storage", or "mounted zip archive" etc.
  *
  * @constructor
+ * @implements {VolumeInfo}
  * @struct
  *
  * @param {VolumeManagerCommon.VolumeType} volumeType The type of the volume.
  * @param {string} volumeId ID of the volume.
  * @param {FileSystem} fileSystem The file system object for this volume.
  * @param {(string|undefined)} error The error if an error is found.
  * @param {(string|undefined)} deviceType The type of device
  *     ('usb'|'sd'|'optical'|'mobile'|'unknown') (as defined in
  *     chromeos/disks/disk_mount_manager.cc). Can be undefined.
  * @param {(string|undefined)} devicePath Identifier of the device that the
  *     volume belongs to. Can be undefined.
  * @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.
  * @param {(string|undefined)} extensionId Id of the extension providing this
  *     volume. Empty for native volumes.
  * @param {boolean} hasMedia When true the volume has been identified
  *     as containing media such as photos or videos.
  * @param {boolean} configurable When true, then the volume can be configured.
  * @param {VolumeManagerCommon.Source} source Source of the volume's data.
  */
-function VolumeInfo(
+function VolumeInfoImpl(
     volumeType,
     volumeId,
     fileSystem,
     error,
     deviceType,
     devicePath,
     isReadOnly,
     profile,
     label,
     extensionId,
@@ skipping 40 matching lines @@
   this.devicePath_ = devicePath;
   this.isReadOnly_ = isReadOnly;
   this.profile_ = Object.freeze(profile);
   this.extensionId_ = extensionId;
   this.hasMedia_ = hasMedia;
   this.configurable_ = configurable;
   this.watchable_ = watchable;
   this.source_ = source;
 }
 
-VolumeInfo.prototype = /** @struct */ {
+VolumeInfoImpl.prototype = /** @struct */ {
   /**
    * @return {VolumeManagerCommon.VolumeType} Volume type.
    */
   get volumeType() {
     return this.volumeType_;
   },
   /**
    * @return {string} Volume ID.
    */
   get volumeId() {
@@ skipping 80 matching lines @@
   },
   /**
    * @return {VolumeManagerCommon.Source} Source of the volume's data.
    */
   get source() {
     return this.source_;
   }
 };
 
 /**
- * Starts resolving the display root and obtains it.  It may take long time for
- * Drive. Once resolved, it is cached.
- *
- * @param {function(!DirectoryEntry)=} opt_onSuccess Success callback with the
- *     display root directory as an argument.
- * @param {function(*)=} opt_onFailure Failure callback.
- * @return {!Promise.<!DirectoryEntry>}
+ * @override
  */
-VolumeInfo.prototype.resolveDisplayRoot = function(opt_onSuccess,
-                                                   opt_onFailure) {
+VolumeInfoImpl.prototype.resolveDisplayRoot = function(opt_onSuccess,
+                                                       opt_onFailure) {
   if (!this.displayRootPromise_) {
     // TODO(mtomasz): Do not add VolumeInfo which failed to resolve root, and
     // remove this if logic. Call opt_onSuccess() always, instead.
     if (this.volumeType !== VolumeManagerCommon.VolumeType.DRIVE) {
       if (this.fileSystem_)
         this.displayRootPromise_ = /** @type {Promise.<!DirectoryEntry>} */ (
             Promise.resolve(this.fileSystem_.root));
       else
         this.displayRootPromise_ = /** @type {Promise.<!DirectoryEntry>} */ (
             Promise.reject(this.error));
@@ skipping 125 matching lines @@
           // it fails, accessing to some path later will just become
           // a fast-fetch and it re-triggers full-feed fetch.
           fileSystem.root.createReader().readEntries(
               function() { /* do nothing */ },
               function(error) {
                 console.error(
                     'Triggering full feed fetch is failed: ' +
                     error.name);
               });
         }
-        return new VolumeInfo(
+        return new VolumeInfoImpl(
             /** @type {VolumeManagerCommon.VolumeType} */
             (volumeMetadata.volumeType),
             volumeMetadata.volumeId,
             fileSystem,
             volumeMetadata.mountCondition,
             volumeMetadata.deviceType,
             volumeMetadata.devicePath,
             volumeMetadata.isReadOnly,
             volumeMetadata.profile,
             localizedLabel,
             volumeMetadata.extensionId,
             volumeMetadata.hasMedia,
             volumeMetadata.configurable,
             volumeMetadata.watchable,
             /** @type {VolumeManagerCommon.Source} */
             (volumeMetadata.source));
   })
   .catch(
       /**
        * @param {*} error
        */
       function(error) {
         console.error('Failed to mount a file system: ' +
             volumeMetadata.volumeId + ' because of: ' +
             (error.stack || error));
         volumeManagerUtil.reportMountError(volumeMetadata, error);
 
-        return new VolumeInfo(
+        return new VolumeInfoImpl(
             /** @type {VolumeManagerCommon.VolumeType} */
             (volumeMetadata.volumeType),
             volumeMetadata.volumeId,
             null,  // File system is not found.
             volumeMetadata.mountCondition,
             volumeMetadata.deviceType,
             volumeMetadata.devicePath,
             volumeMetadata.isReadOnly,
             volumeMetadata.profile,
             localizedLabel,
@@ skipping 806 matching lines @@
       this.rootType === VolumeManagerCommon.RootType.DRIVE_OFFLINE;
 
   /**
    * Whether the entry is read only or not.
    * @type {boolean}
    */
   this.isReadOnly = isReadOnly;
 
   Object.freeze(this);
 }