Show the eject button only for removabled and file handlers.

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
  * @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(
     volumeType,
     volumeId,
     fileSystem,
     error,
     deviceType,
     devicePath,
     isReadOnly,
     profile,
     label,
     extensionId,
     hasMedia,
-    configurable) {
+    configurable,
+    source) {
   this.volumeType_ = volumeType;
   this.volumeId_ = volumeId;
   this.fileSystem_ = fileSystem;
   this.label_ = label;
   this.displayRoot_ = null;
 
   /** @type {Object.<string, !FakeEntry>} */
   this.fakeEntries_ = {};
 
   /** @type {Promise.<!DirectoryEntry>} */
@@ skipping 22 matching lines @@
   // or not. (If error is empty string, the mount is successfully done).
   // TODO(hidehiko): Rename to make this more understandable.
   this.error_ = error;
   this.deviceType_ = deviceType;
   this.devicePath_ = devicePath;
   this.isReadOnly_ = isReadOnly;
   this.profile_ = Object.freeze(profile);
   this.extensionId_ = extensionId;
   this.hasMedia_ = hasMedia;
   this.configurable_ = configurable;
+  this.source_ = source;
 }
 
 VolumeInfo.prototype = /** @struct */ {
   /**
    * @return {VolumeManagerCommon.VolumeType} Volume type.
    */
   get volumeType() {
     return this.volumeType_;
   },
   /**
@@ skipping 67 matching lines @@
    * @return {boolean} True if the volume contains media.
    */
   get hasMedia() {
     return this.hasMedia_;
   },
   /**
    * @return {boolean} True if the volume is configurable.
    */
   get configurable() {
     return this.configurable_;
+  },
+  /**
+   * @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.
@@ skipping 64 matching lines @@
       break;
     default:
       // TODO(mtomasz): Calculate volumeLabel for all types of volumes in the
       // C++ layer.
       localizedLabel = volumeMetadata.volumeLabel ||
           volumeMetadata.volumeId.split(':', 2)[1];
       break;
   }
 
   console.debug('Requesting file system.');
-  var configurable = false;
-
   return new Promise(
       function(resolve, reject) {
-        if (volumeMetadata.volumeType !==
-            VolumeManagerCommon.VolumeType.PROVIDED) {
-          resolve();
-        }
-
-        chrome.fileManagerPrivate.getProvidingExtensions(
-            function(extensions) {
-              if (chrome.runtime.lastError) {
+        chrome.fileSystem.requestFileSystem(
+            {
+              volumeId: volumeMetadata.volumeId,
+              writable: !volumeMetadata.isReadOnly
+            },
+            function(isolatedFileSystem) {
+              if (chrome.runtime.lastError)
                 reject(chrome.runtime.lastError.message);
-                return;
-              }
-              configurable = extensions.some(function(extension) {
-                return extension.extensionId === volumeMetadata.extensionId &&
-                    extension.configurable;
-              });
-              resolve();
+              else
+                resolve(isolatedFileSystem);
             });
       })
-      .then(
-          function() {
-            return new Promise(function(resolve, reject) {
-              chrome.fileSystem.requestFileSystem(
-                  {
-                    volumeId: volumeMetadata.volumeId,
-                    writable: !volumeMetadata.isReadOnly
-                  },
-                  function(isolatedFileSystem) {
-                    if (chrome.runtime.lastError)
-                      reject(chrome.runtime.lastError.message);
-                    else
-                      resolve(isolatedFileSystem);
-                  });
-            });
-          })
-      .then(
-          /**
-           * @param {!FileSystem} isolatedFileSystem
-           */
-          function(isolatedFileSystem) {
-            // Since File System API works on isolated entries only, we need to
-            // convert it back to external one.
-            // TODO(mtomasz): Make Files app work on isolated entries.
-            return new Promise(function(resolve, reject) {
-              chrome.fileManagerPrivate.resolveIsolatedEntries(
-                  [isolatedFileSystem.root],
-                  function(entries) {
-                    if (chrome.runtime.lastError)
-                      reject(chrome.runtime.lastError.message);
-                    else if (!entries[0])
-                      reject('Resolving for external context failed.');
-                    else
-                      resolve(entries[0].filesystem);
-                  });
+  .then(
+      /**
+       * @param {!FileSystem} isolatedFileSystem
+       */
+      function(isolatedFileSystem) {
+        // Since File System API works on isolated entries only, we need to
+        // convert it back to external one.
+        // TODO(mtomasz): Make Files app work on isolated entries.
+        return new Promise(function(resolve, reject) {
+          chrome.fileManagerPrivate.resolveIsolatedEntries(
+              [isolatedFileSystem.root],
+              function(entries) {
+                if (chrome.runtime.lastError)
+                  reject(chrome.runtime.lastError.message);
+                else if (!entries[0])
+                  reject('Resolving for external context failed.');
+                else
+                  resolve(entries[0].filesystem);
               });
-           })
-      .then(
-          /**
-           * @param {!FileSystem} fileSystem
-           */
-          function(fileSystem) {
-            console.debug('File system obtained: ' + volumeMetadata.volumeId);
-              if (volumeMetadata.volumeType ===
-                  VolumeManagerCommon.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.
-                fileSystem.root.createReader().readEntries(
-                    function() { /* do nothing */ },
-                    function(error) {
-                      console.error(
-                          'Triggering full feed fetch is failed: ' +
-                          error.name);
-                    });
-              }
-              return new VolumeInfo(
-                  /** @type {VolumeManagerCommon.VolumeType} */
-                  (volumeMetadata.volumeType),
-                  volumeMetadata.volumeId,
-                  fileSystem,
-                  volumeMetadata.mountCondition,
-                  volumeMetadata.deviceType,
-                  volumeMetadata.devicePath,
-                  volumeMetadata.isReadOnly,
-                  volumeMetadata.profile,
-                  localizedLabel,
-                  volumeMetadata.extensionId,
-                  volumeMetadata.hasMedia,
-                  configurable);
-      })
-      .catch(
-          /**
-           * @param {*} error
-           */
-          function(error) {
-            console.error('Failed to mount a file system: ' +
-                volumeMetadata.volumeId + ' because of: ' +
-                (error.stack || error));
-            return new VolumeInfo(
-                /** @type {VolumeManagerCommon.VolumeType} */
-                (volumeMetadata.volumeType),
-                volumeMetadata.volumeId,
-                null,  // File system is not found.
-                volumeMetadata.mountCondition,
-                volumeMetadata.deviceType,
-                volumeMetadata.devicePath,
-                volumeMetadata.isReadOnly,
-                volumeMetadata.profile,
-                localizedLabel,
-                volumeMetadata.extensionId,
-                volumeMetadata.hasMedia,
-                configurable);
           });
+       })
+  .then(
+      /**
+       * @param {!FileSystem} fileSystem
+       */
+      function(fileSystem) {
+        console.debug('File system obtained: ' + volumeMetadata.volumeId);
+        if (volumeMetadata.volumeType ===
+            VolumeManagerCommon.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.
+          fileSystem.root.createReader().readEntries(
+              function() { /* do nothing */ },
+              function(error) {
+                console.error(
+                    'Triggering full feed fetch is failed: ' +
+                    error.name);
+              });
+        }
+        return new VolumeInfo(
+            /** @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,
+            /** @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));
+        return new VolumeInfo(
+            /** @type {VolumeManagerCommon.VolumeType} */
+            (volumeMetadata.volumeType),
+            volumeMetadata.volumeId,
+            null,  // File system is not found.
+            volumeMetadata.mountCondition,
+            volumeMetadata.deviceType,
+            volumeMetadata.devicePath,
+            volumeMetadata.isReadOnly,
+            volumeMetadata.profile,
+            localizedLabel,
+            volumeMetadata.extensionId,
+            volumeMetadata.hasMedia,
+            volumeMetadata.configurable,
+            /** @type {VolumeManagerCommon.Source} */
+            (volumeMetadata.source));
+      });
 };
 
 /**
  * The order of the volume list based on root type.
  * @type {Array.<VolumeManagerCommon.VolumeType>}
  * @const
  * @private
  */
 volumeManagerUtil.volumeListOrder_ = [
   VolumeManagerCommon.VolumeType.DRIVE,
@@ skipping 727 matching lines @@
       this.isDriveBased;
 
   /**
    * Whether the entry is read only or not.
    * @type {boolean}
    */
   this.isReadOnly = isReadOnly;
 
   Object.freeze(this);
 }