[Media Galleries] Move RemovableStorageInfo notifications to chrome namespace (part 2)

chrome/browser/system_monitor/media_transfer_protocol_device_observer_linux.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/system_monitor/media_transfer_protocol_device_observer_linux.h"
 
 #include "base/file_path.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/system_monitor/media_storage_util.h"
 #include "chrome/browser/system_monitor/removable_device_constants.h"
 #include "device/media_transfer_protocol/mtp_storage_info.pb.h"
 
 namespace chrome {
 
-using base::SystemMonitor;
-
 namespace {
 
 static MediaTransferProtocolDeviceObserverLinux* g_mtp_device_observer = NULL;
 
 // Device root path constant.
 const char kRootPath[] = "/";
 
 // Constructs and returns the location of the device using the |storage_name|.
 std::string GetDeviceLocationFromStorageName(const std::string& storage_name) {
   // Construct a dummy device path using the storage name. This is only used
@@ skipping 128 matching lines @@
 
 // static
 MediaTransferProtocolDeviceObserverLinux*
 MediaTransferProtocolDeviceObserverLinux::GetInstance() {
   DCHECK(g_mtp_device_observer != NULL);
   return g_mtp_device_observer;
 }
 
 bool MediaTransferProtocolDeviceObserverLinux::GetStorageInfoForPath(
     const FilePath& path,
-    SystemMonitor::RemovableStorageInfo* storage_info) const {
+    RemovableStorageNotifications::StorageInfo* storage_info) const {
   if (!path.IsAbsolute())
     return false;
 
   std::vector<FilePath::StringType> path_components;
   path.GetComponents(&path_components);
   if (path_components.size() < 2)
     return false;
 
   // First and second component of the path specifies the device location.
   // E.g.: If |path| is "/usb:2,2:65537/DCIM/Folder_a", "/usb:2,2:65537" is the
   // device location.
   StorageLocationToInfoMap::const_iterator info_it =
       storage_map_.find(GetDeviceLocationFromStorageName(path_components[1]));
   if (info_it == storage_map_.end())
     return false;
 
   if (storage_info)
     *storage_info = info_it->second;
   return true;
 }
 
 // device::MediaTransferProtocolManager::Observer override.
 void MediaTransferProtocolDeviceObserverLinux::StorageChanged(
     bool is_attached,
     const std::string& storage_name) {
   DCHECK(!storage_name.empty());
 
-  SystemMonitor* system_monitor = SystemMonitor::Get();
-  DCHECK(system_monitor);
+  RemovableStorageNotifications* notifications =
+      RemovableStorageNotifications::GetInstance();
+  DCHECK(notifications);
 
   // New storage is attached.
   if (is_attached) {
     std::string device_id;
     string16 device_name;
     std::string location;
     get_storage_info_func_(storage_name, &device_id, &device_name, &location);
 
     // Keep track of device id and device name to see how often we receive
     // empty values.
     MediaStorageUtil::RecordDeviceInfoHistogram(false, device_id, device_name);
     if (device_id.empty() || device_name.empty())
       return;
 
     DCHECK(!ContainsKey(storage_map_, location));
 
-    SystemMonitor::RemovableStorageInfo storage_info(device_id, device_name,
-                                                     location);
+    RemovableStorageNotifications::StorageInfo storage_info(
+        device_id, device_name, location);
     storage_map_[location] = storage_info;
-    system_monitor->ProcessRemovableStorageAttached(device_id, device_name,
-                                                    location);
+    notifications->ProcessAttach(device_id, device_name,
+                                                   location);
   } else {
     // Existing storage is detached.
     StorageLocationToInfoMap::iterator it =
         storage_map_.find(GetDeviceLocationFromStorageName(storage_name));
     if (it == storage_map_.end())
       return;
-    system_monitor->ProcessRemovableStorageDetached(it->second.device_id);
+    notifications->ProcessDetach(it->second.device_id);
     storage_map_.erase(it);
   }
 }
 
 void MediaTransferProtocolDeviceObserverLinux::EnumerateStorages() {
   typedef std::vector<std::string> StorageList;
   device::MediaTransferProtocolManager* mtp_manager =
       device::MediaTransferProtocolManager::GetInstance();
   StorageList storages = mtp_manager->GetStorages();
   for (StorageList::const_iterator storage_iter = storages.begin();
        storage_iter != storages.end(); ++storage_iter) {
     StorageChanged(true, *storage_iter);
   }
 }
 
 }  // namespace chrome