[CrosDisksClient] Determine device type from DeviceMediaType property sent by cros-disks.

chrome/browser/extensions/extension_file_browser_private_api.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_file_browser_private_api.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 31 matching lines @@
 #include "grit/generated_resources.h"
 #include "grit/platform_locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
+#ifdef OS_CHROMEOS
+#include "chrome/browser/chromeos/disks/disk_mount_manager.h"
+#endif
+
+using chromeos::disks::DiskMountManager;
 using content::BrowserThread;
 using content::SiteInstance;
 using content::WebContents;
 
 namespace {
 
 // Error messages.
 const char kFileError[] = "File error %d";
 const char kInvalidFileUrl[] = "Invalid file URL";
 const char kVolumeDevicePathNotFound[] = "Device path not found";
@@ skipping 197 matching lines @@
   DictionaryPrefUpdate prefs_usage_update(profile->GetPrefs(),
       prefs::kLastUsedFileBrowserHandlers);
   prefs_usage_update->SetWithoutPathExpansion(task_id,
       new base::FundamentalValue(
           static_cast<int>(base::Time::Now().ToInternalValue()/
                            base::Time::kMicrosecondsPerSecond)));
 }
 
 #ifdef OS_CHROMEOS
 base::DictionaryValue* MountPointToValue(Profile* profile,
-    const chromeos::disks::DiskMountManager::MountPointInfo& mount_point_info) {
+    const DiskMountManager::MountPointInfo& mount_point_info) {
 
     base::DictionaryValue *mount_info = new base::DictionaryValue();
 
     mount_info->SetString("mountType",
-                          chromeos::disks::DiskMountManager::MountTypeToString(
+                          DiskMountManager::MountTypeToString(
                               mount_point_info.mount_type));
 
     if (mount_point_info.mount_type == chromeos::MOUNT_TYPE_ARCHIVE) {
       GURL source_url;
       if (file_manager_util::ConvertFileToFileSystemUrl(profile,
               FilePath(mount_point_info.source_path),
               file_manager_util::GetFileBrowserExtensionUrl().GetOrigin(),
               &source_url)) {
         mount_info->SetString("sourceUrl", source_url.spec());
       }
     } else {
       mount_info->SetString("sourceUrl", mount_point_info.source_path);
     }
 
     FilePath relative_mount_path;
     // Convert mount point path to relative path with the external file system
     // exposed within File API.
     if (file_manager_util::ConvertFileToRelativeFileSystemPath(profile,
             FilePath(mount_point_info.mount_path),
             &relative_mount_path)) {
       mount_info->SetString("mountPath", relative_mount_path.value());
     }
 
     mount_info->SetString("mountCondition",
-        chromeos::disks::DiskMountManager::MountConditionToString(
-        mount_point_info.mount_condition));
+        DiskMountManager::MountConditionToString(
+            mount_point_info.mount_condition));
 
     return mount_info;
 }
 #endif
 
 }  // namespace
 
 class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher
     : public fileapi::FileSystemCallbackDispatcher {
  public:
@@ skipping 926 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!files.size()) {
     SendResponse(false);
     return;
   }
 
 #ifdef OS_CHROMEOS
   FilePath::StringType source_file = files[0].value();
 
-  chromeos::disks::DiskMountManager* disk_mount_manager =
-      chromeos::disks::DiskMountManager::GetInstance();
+  DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
 
   chromeos::MountType mount_type =
       disk_mount_manager->MountTypeFromString(mount_type_str);
   if (mount_type == chromeos::MOUNT_TYPE_INVALID) {
     error_ = "Invalid mount type";
     SendResponse(false);
     return;
   }
 
   disk_mount_manager->MountPath(source_file.data(), mount_type);
@@ skipping 28 matching lines @@
 
 void RemoveMountFunction::GetLocalPathsResponseOnUIThread(
     const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 #ifdef OS_CHROMEOS
-  chromeos::disks::DiskMountManager::GetInstance()->UnmountPath(
-      files[0].value());
+  DiskMountManager::GetInstance()->UnmountPath(files[0].value());
 #endif
 
   SendResponse(true);
 }
 
 GetMountPointsFunction::GetMountPointsFunction() {
 }
 
 GetMountPointsFunction::~GetMountPointsFunction() {
 }
 
 bool GetMountPointsFunction::RunImpl() {
   if (args_->GetSize())
     return false;
 
   base::ListValue *mounts = new base::ListValue();
   result_.reset(mounts);
 
 #ifdef OS_CHROMEOS
-  chromeos::disks::DiskMountManager* disk_mount_manager =
-      chromeos::disks::DiskMountManager::GetInstance();
-  chromeos::disks::DiskMountManager::MountPointMap mount_points =
+  DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
+  DiskMountManager::MountPointMap mount_points =
       disk_mount_manager->mount_points();
 
-  for (chromeos::disks::DiskMountManager::MountPointMap::const_iterator it =
+  for (DiskMountManager::MountPointMap::const_iterator it =
            mount_points.begin();
        it != mount_points.end();
        ++it) {
     mounts->Append(MountPointToValue(profile_, it->second));
   }
 #endif
 
   SendResponse(true);
   return true;
 }
@@ skipping 39 matching lines @@
           files[0].value()));
 }
 
 void GetSizeStatsFunction::CallGetSizeStatsOnFileThread(
     const std::string& mount_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   size_t total_size_kb = 0;
   size_t remaining_size_kb = 0;
 #ifdef OS_CHROMEOS
-  chromeos::disks::DiskMountManager::GetInstance()->
+  DiskMountManager::GetInstance()->
       GetSizeStatsOnFileThread(mount_path, &total_size_kb, &remaining_size_kb);
 #endif
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &GetSizeStatsFunction::GetSizeStatsCallbackOnUIThread,
           this,
           mount_path, total_size_kb, remaining_size_kb));
 }
@@ skipping 42 matching lines @@
 void FormatDeviceFunction::GetLocalPathsResponseOnUIThread(
     const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
 #ifdef OS_CHROMEOS
-  chromeos::disks::DiskMountManager::GetInstance()->FormatMountedDevice(
-      files[0].value());
+  DiskMountManager::GetInstance()->FormatMountedDevice(files[0].value());
 #endif
 
   SendResponse(true);
 }
 
 GetVolumeMetadataFunction::GetVolumeMetadataFunction() {
 }
 
 GetVolumeMetadataFunction::~GetVolumeMetadataFunction() {
 }
 
 bool GetVolumeMetadataFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     error_ = "Invalid argument count";
     return false;
   }
 
   std::string volume_device_path;
   if (!args_->GetString(0, &volume_device_path)) {
     NOTREACHED();
   }
 
 #ifdef OS_CHROMEOS
-  chromeos::disks::DiskMountManager* disk_mount_manager =
-      chromeos::disks::DiskMountManager::GetInstance();
-  chromeos::disks::DiskMountManager::DiskMap::const_iterator volume_it =
+  DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
+  DiskMountManager::DiskMap::const_iterator volume_it =
       disk_mount_manager->disks().find(volume_device_path);
 
   if (volume_it != disk_mount_manager->disks().end() &&
       !volume_it->second->is_hidden()) {
-    chromeos::disks::DiskMountManager::Disk* volume = volume_it->second;
+    DiskMountManager::Disk* volume = volume_it->second;
     DictionaryValue* volume_info = new DictionaryValue();
     result_.reset(volume_info);
     // Localising mount path.
     std::string mount_path;
     if (!volume->mount_path().empty()) {
       FilePath relative_mount_path;
       file_manager_util::ConvertFileToRelativeFileSystemPath(profile_,
           FilePath(volume->mount_path()), &relative_mount_path);
       mount_path = relative_mount_path.value();
     }
     volume_info->SetString("devicePath", volume->device_path());
     volume_info->SetString("mountPath", mount_path);
     volume_info->SetString("systemPath", volume->system_path());
     volume_info->SetString("filePath", volume->file_path());
     volume_info->SetString("deviceLabel", volume->device_label());
     volume_info->SetString("driveLabel", volume->drive_label());
     volume_info->SetString("deviceType",
-        DeviceTypeToString(volume->device_type()));
+        DiskMountManager::DeviceTypeToString(volume->device_type()));
     volume_info->SetInteger("totalSize", volume->total_size_in_bytes());
     volume_info->SetBoolean("isParent", volume->is_parent());
     volume_info->SetBoolean("isReadOnly", volume->is_read_only());
     volume_info->SetBoolean("hasMedia", volume->has_media());
     volume_info->SetBoolean("isOnBootDevice", volume->on_boot_device());
 
     return true;
   }
 #endif
   error_ = kVolumeDevicePathNotFound;
   return false;
 }
 
-#ifdef OS_CHROMEOS
-std::string GetVolumeMetadataFunction::DeviceTypeToString(
-    chromeos::DeviceType type) {
-  switch (type) {
-    case chromeos::FLASH:
-      return kVolumeTypeFlash;
-    case chromeos::OPTICAL:
-      return kVolumeTypeOptical;
-    case chromeos::HDD:
-      return kVolumeTypeHardDrive;
-    default:
-      break;
-  }
-  return kVolumeTypeUnknown;
-}
-#endif
-
 bool FileDialogStringsFunction::RunImpl() {
   result_.reset(new DictionaryValue());
   DictionaryValue* dict = reinterpret_cast<DictionaryValue*>(result_.get());
 
 #define SET_STRING(ns, id) \
   dict->SetString(#id, l10n_util::GetStringUTF16(ns##_##id))
 
   SET_STRING(IDS, WEB_FONT_FAMILY);
   SET_STRING(IDS, WEB_FONT_SIZE);
 
@@ skipping 154 matching lines @@
   SET_STRING(IDS_FILE_BROWSER, ENQUEUE);
 #undef SET_STRING
 
   ChromeURLDataManager::DataSource::SetFontAndTextDirection(dict);
 
   dict->SetString("PLAY_MEDIA",
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_PLAY));
 
   return true;
 }