Consolidate storage_monitor/MediaDeviceNotificationsUtils into MediaStorageUtil.

chrome/browser/storage_monitor/storage_monitor_chromeos.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.
 
 // chromeos::StorageMonitorCros implementation.
 
 #include "chrome/browser/storage_monitor/storage_monitor_chromeos.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/storage_monitor/media_device_notifications_utils.h"
 #include "chrome/browser/storage_monitor/media_storage_util.h"
 #include "chrome/browser/storage_monitor/removable_device_constants.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
 
 namespace {
 
 // Constructs a device name using label or manufacturer (vendor and product)
 // name details.
 string16 GetDeviceName(const disks::DiskMountManager::Disk& disk) {
   if (disk.device_type() == DEVICE_TYPE_SD) {
     // Mount path of an SD card will be one of the following:
     // (1) /media/removable/<volume_label>
     // (2) /media/removable/SD Card
     // If the volume label is available, mount path will be (1) else (2).
     base::FilePath mount_point(disk.mount_path());
     const string16 display_name(mount_point.BaseName().LossyDisplayName());
     if (!display_name.empty())
       return display_name;
   }
 
   const std::string& device_label = disk.device_label();
   if (!device_label.empty() && IsStringUTF8(device_label))
     return UTF8ToUTF16(device_label);
-  return chrome::GetFullProductName(disk.vendor_name(), disk.product_name());
+  return chrome::MediaStorageUtil::GetFullProductName(disk.vendor_name(),
+                                                      disk.product_name());
 }
 
 // Constructs a device id using uuid or manufacturer (vendor and product) id
 // details.
 std::string MakeDeviceUniqueId(const disks::DiskMountManager::Disk& disk) {
   std::string uuid = disk.fs_uuid();
   if (!uuid.empty())
     return chrome::kFSUniqueIdPrefix + uuid;
 
   // If one of the vendor or product information is missing, its value in the
@@ skipping 26 matching lines @@
     *device_label = GetDeviceName(*disk);
 
   if (storage_size_in_bytes)
     *storage_size_in_bytes = disk->total_size_in_bytes();
   return true;
 }
 
 }  // namespace
 
 using content::BrowserThread;
+using chrome::StorageInfo;
 
 StorageMonitorCros::StorageMonitorCros() {
   DCHECK(disks::DiskMountManager::GetInstance());
   disks::DiskMountManager::GetInstance()->AddObserver(this);
   CheckExistingMountPointsOnUIThread();
 }
 
 StorageMonitorCros::~StorageMonitorCros() {
   disks::DiskMountManager* manager = disks::DiskMountManager::GetInstance();
   if (manager) {
@@ skipping 64 matching lines @@
 }
 
 void StorageMonitorCros::OnFormatEvent(
     disks::DiskMountManager::FormatEvent event,
     FormatError error_code,
     const std::string& device_path) {
 }
 
 bool StorageMonitorCros::GetStorageInfoForPath(
     const base::FilePath& path,
-    chrome::StorageInfo* device_info) const {
+    StorageInfo* device_info) const {
   if (!path.IsAbsolute())
     return false;
 
   base::FilePath current = path;
   while (!ContainsKey(mount_map_, current.value()) &&
          current != current.DirName()) {
     current = current.DirName();
   }
 
   MountMap::const_iterator info_it = mount_map_.find(current.value());
   if (info_it == mount_map_.end())
     return false;
 
   if (device_info)
     *device_info = info_it->second.storage_info;
   return true;
 }
 
 uint64 StorageMonitorCros::GetStorageSize(
     const std::string& device_location) const {
   MountMap::const_iterator info_it = mount_map_.find(device_location);
   return (info_it != mount_map_.end()) ?
       info_it->second.storage_size_in_bytes : 0;
 }
 
 void StorageMonitorCros::CheckMountedPathOnFileThread(
     const disks::DiskMountManager::MountPointInfo& mount_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  bool has_dcim = chrome::IsMediaDevice(mount_info.mount_path);
+  bool has_dcim = chrome::MediaStorageUtil::HasDcim(mount_info.mount_path);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&StorageMonitorCros::AddMountedPathOnUIThread, this,
                  mount_info, has_dcim));
 }
 
 void StorageMonitorCros::AddMountedPathOnUIThread(
     const disks::DiskMountManager::MountPointInfo& mount_info, bool has_dcim) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 20 matching lines @@
   if (unique_id.empty() || device_label.empty())
     return;
 
   chrome::MediaStorageUtil::Type type = has_dcim ?
       chrome::MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM :
       chrome::MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM;
 
   std::string device_id = chrome::MediaStorageUtil::MakeDeviceId(type,
                                                                  unique_id);
   StorageObjectInfo object_info = {
-      chrome::StorageInfo(device_id, device_label, mount_info.mount_path),
+      StorageInfo(device_id, device_label, mount_info.mount_path),
       storage_size_in_bytes
   };
   mount_map_.insert(std::make_pair(mount_info.mount_path, object_info));
-  receiver()->ProcessAttach(chrome::StorageInfo(
-      device_id,
-      chrome::GetDisplayNameForDevice(storage_size_in_bytes, device_label),
-      mount_info.mount_path));
+
+  string16 display_name = chrome::MediaStorageUtil::GetDisplayNameForDevice(
+      storage_size_in_bytes,
+      device_label);
+
+  StorageInfo storage_info(device_id, display_name, mount_info.mount_path);
+  receiver()->ProcessAttach(storage_info);
 }
 
 }  // namespace chromeos