Show the eject button only for removabled and file handlers.

chrome/browser/chromeos/file_manager/volume_manager.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 112 matching lines @@
 std::string GetMountPointNameForMediaStorage(
     const storage_monitor::StorageInfo& info) {
   std::string name(kFileManagerMTPMountNamePrefix);
   name += info.device_id();
   return name;
 }
 
 }  // namespace
 
 Volume::Volume()
-    : type_(VOLUME_TYPE_GOOGLE_DRIVE),
+    : source_(SOURCE_FILE),
+      type_(VOLUME_TYPE_GOOGLE_DRIVE),
       device_type_(chromeos::DEVICE_TYPE_UNKNOWN),
       mount_condition_(chromeos::disks::MOUNT_CONDITION_NONE),
       mount_context_(MOUNT_CONTEXT_UNKNOWN),
       is_parent_(false),
       is_read_only_(false),
-      has_media_(false) {
+      has_media_(false),
+      configurable_(false) {
 }
 
 Volume::~Volume() {
 }
 
 // static
 Volume* Volume::CreateForDrive(Profile* profile) {
   const base::FilePath& drive_path =
       drive::util::GetDriveMountPointPath(profile);
   Volume* const volume = new Volume;
   volume->type_ = VOLUME_TYPE_GOOGLE_DRIVE;
   volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
   volume->source_path_ = drive_path;
+  volume->source_ = SOURCE_NETWORK;
   volume->mount_path_ = drive_path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
-  volume->is_parent_ = false;
-  volume->is_read_only_ = false;
-  volume->has_media_ = false;
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
 Volume* Volume::CreateForDownloads(const base::FilePath& downloads_path) {
   Volume* const volume = new Volume;
   volume->type_ = VOLUME_TYPE_DOWNLOADS_DIRECTORY;
   volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
   // Keep source_path empty.
+  volume->source_ = SOURCE_SYSTEM;
   volume->mount_path_ = downloads_path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
-  volume->is_parent_ = false;
-  volume->is_read_only_ = false;
-  volume->has_media_ = false;
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
 Volume* Volume::CreateForRemovable(
     const chromeos::disks::DiskMountManager::MountPointInfo& mount_point,
     const chromeos::disks::DiskMountManager::Disk* disk) {
   Volume* const volume = new Volume;
   volume->type_ = MountTypeToVolumeType(mount_point.mount_type);
   volume->source_path_ = base::FilePath(mount_point.source_path);
+  volume->source_ = mount_point.mount_type == chromeos::MOUNT_TYPE_ARCHIVE
+                        ? SOURCE_FILE
+                        : SOURCE_DEVICE;
   volume->mount_path_ = base::FilePath(mount_point.mount_path);
   volume->mount_condition_ = mount_point.mount_condition;
   volume->volume_label_ = volume->mount_path().BaseName().AsUTF8Unsafe();
   if (disk) {
     volume->device_type_ = disk->device_type();
     volume->system_path_prefix_ = base::FilePath(disk->system_path_prefix());
     volume->is_parent_ = disk->is_parent();
     volume->is_read_only_ = disk->is_read_only();
     volume->has_media_ = disk->has_media();
   } else {
     volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
-    volume->is_parent_ = false;
     volume->is_read_only_ =
         (mount_point.mount_type == chromeos::MOUNT_TYPE_ARCHIVE);
-    volume->has_media_ = false;
   }
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
 Volume* Volume::CreateForProvidedFileSystem(
     const chromeos::file_system_provider::ProvidedFileSystemInfo&
         file_system_info,
     MountContext mount_context) {
   Volume* const volume = new Volume;
   volume->file_system_id_ = file_system_info.file_system_id();
   volume->extension_id_ = file_system_info.extension_id();
+  switch (file_system_info.source()) {
+    case extensions::SOURCE_FILE:
+      volume->source_ = SOURCE_FILE;
+      break;
+    case extensions::SOURCE_DEVICE:
+      volume->source_ = SOURCE_DEVICE;
+      break;
+    case extensions::SOURCE_NETWORK:
+      volume->source_ = SOURCE_NETWORK;
+      break;
+  }
   volume->volume_label_ = file_system_info.display_name();
   volume->type_ = VOLUME_TYPE_PROVIDED;
   volume->mount_path_ = file_system_info.mount_path();
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->mount_context_ = mount_context;
   volume->is_parent_ = true;
   volume->is_read_only_ = !file_system_info.writable();
-  volume->has_media_ = false;
+  volume->configurable_ = file_system_info.configurable();
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
 Volume* Volume::CreateForMTP(const base::FilePath& mount_path,
                              const std::string& label,
                              bool read_only) {
   Volume* const volume = new Volume;
   volume->type_ = VOLUME_TYPE_MTP;
   volume->mount_path_ = mount_path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->is_parent_ = true;
   volume->is_read_only_ = read_only;
   volume->volume_id_ = kMtpVolumeIdPrefix + label;
   volume->volume_label_ = label;
   volume->source_path_ = mount_path;
+  volume->source_ = SOURCE_DEVICE;
   volume->device_type_ = chromeos::DEVICE_TYPE_MOBILE;
   return volume;
 }
 
 // static
 Volume* Volume::CreateForTesting(const base::FilePath& path,
                                  VolumeType volume_type,
                                  chromeos::DeviceType device_type,
                                  bool read_only) {
   Volume* const volume = new Volume;
   volume->type_ = volume_type;
   volume->device_type_ = device_type;
   // Keep source_path empty.
+  volume->source_ = SOURCE_DEVICE;
   volume->mount_path_ = path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
-  volume->is_parent_ = false;
   volume->is_read_only_ = read_only;
-  volume->has_media_ = false;
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
 Volume* Volume::CreateForTesting(const base::FilePath& device_path,
                                  const base::FilePath& mount_path) {
   Volume* const volume = new Volume;
   volume->system_path_prefix_ = device_path;
   volume->mount_path_ = mount_path;
@@ skipping 149 matching lines @@
 void VolumeManager::AddVolumeForTesting(const base::FilePath& path,
                                         VolumeType volume_type,
                                         chromeos::DeviceType device_type,
                                         bool read_only) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DoMountEvent(chromeos::MOUNT_ERROR_NONE,
                make_linked_ptr(Volume::CreateForTesting(
                    path, volume_type, device_type, read_only)));
 }
 
+void VolumeManager::AddVolumeForTesting(const linked_ptr<Volume>& volume) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume);
+}
+
 void VolumeManager::OnFileSystemMounted() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Raise mount event.
   // We can pass chromeos::MOUNT_ERROR_NONE even when authentication is failed
   // or network is unreachable. These two errors will be handled later.
   linked_ptr<Volume> volume(Volume::CreateForDrive(profile_));
   DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume);
 }
 
@@ skipping 344 matching lines @@
 
 void VolumeManager::OnStorageMonitorInitialized() {
   std::vector<storage_monitor::StorageInfo> storages =
       storage_monitor::StorageMonitor::GetInstance()->GetAllAvailableStorages();
   for (size_t i = 0; i < storages.size(); ++i)
     OnRemovableStorageAttached(storages[i]);
   storage_monitor::StorageMonitor::GetInstance()->AddObserver(this);
 }
 
 void VolumeManager::DoMountEvent(chromeos::MountError error_code,
-                                 linked_ptr<Volume> volume) {
+                                 const linked_ptr<Volume>& volume) {
   // Archive files are mounted globally in system. We however don't want to show
   // archives from profile-specific folders (Drive/Downloads) of other users in
   // multi-profile session. To this end, we filter out archives not on the
   // volumes already mounted on this VolumeManager instance.
   if (volume->type() == VOLUME_TYPE_MOUNTED_ARCHIVE_FILE) {
     // Source may be in Drive cache folder under the current profile directory.
     bool from_current_profile =
         profile_->GetPath().IsParent(volume->source_path());
     for (const auto& mounted_volume : mounted_volumes_) {
       if (mounted_volume.second->mount_path().IsParent(volume->source_path())) {
@@ skipping 15 matching lines @@
     mounted_volumes_[volume->volume_id()] = volume;
     UMA_HISTOGRAM_ENUMERATION("FileBrowser.VolumeType", volume->type(),
                               NUM_VOLUME_TYPE);
   }
 
   FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
                     OnVolumeMounted(error_code, *volume));
 }
 
 void VolumeManager::DoUnmountEvent(chromeos::MountError error_code,
-                                   linked_ptr<Volume> volume) {
+                                   const linked_ptr<Volume>& volume) {
   if (mounted_volumes_.find(volume->volume_id()) == mounted_volumes_.end())
     return;
   if (error_code == chromeos::MOUNT_ERROR_NONE)
     mounted_volumes_.erase(volume->volume_id());
 
   FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
                     OnVolumeUnmounted(error_code, *volume.get()));
 }
 
 }  // namespace file_manager