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

chrome/browser/system_monitor/removable_device_notifications_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.
 
 // RemovableDeviceNotificationsLinux implementation.
 
 #include "chrome/browser/system_monitor/removable_device_notifications_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
-#include "base/system_monitor/system_monitor.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/system_monitor/media_device_notifications_utils.h"
 #include "chrome/browser/system_monitor/media_storage_util.h"
 #include "chrome/browser/system_monitor/removable_device_constants.h"
 #include "chrome/browser/system_monitor/udev_util_linux.h"
 
 namespace chrome {
 
 using content::BrowserThread;
 
 namespace {
 
-static RemovableDeviceNotificationsLinux*
-    g_removable_device_notifications_linux = NULL;
-
 // List of file systems we care about.
 const char* const kKnownFileSystems[] = {
   "ext2",
   "ext3",
   "ext4",
   "fat",
   "hfsplus",
   "iso9660",
   "msdos",
   "ntfs",
@@ skipping 179 matching lines @@
   RecordGetDeviceInfoResult(true);
 }
 
 }  // namespace
 
 RemovableDeviceNotificationsLinux::RemovableDeviceNotificationsLinux(
     const FilePath& path)
     : initialized_(false),
       mtab_path_(path),
       get_device_info_func_(&GetDeviceInfo) {
-  DCHECK(!g_removable_device_notifications_linux);
-  g_removable_device_notifications_linux = this;
 }
 
 RemovableDeviceNotificationsLinux::RemovableDeviceNotificationsLinux(
     const FilePath& path,
     GetDeviceInfoFunc get_device_info_func)
     : initialized_(false),
       mtab_path_(path),
       get_device_info_func_(get_device_info_func) {
-  DCHECK(!g_removable_device_notifications_linux);
-  g_removable_device_notifications_linux = this;
 }
 
 RemovableDeviceNotificationsLinux::~RemovableDeviceNotificationsLinux() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK_EQ(this, g_removable_device_notifications_linux);
-  g_removable_device_notifications_linux = NULL;
 }
 
 void RemovableDeviceNotificationsLinux::Init() {
   DCHECK(!mtab_path_.empty());
 
   // Put |kKnownFileSystems| in std::set to get O(log N) access time.
   for (size_t i = 0; i < arraysize(kKnownFileSystems); ++i)
     known_file_systems_.insert(kKnownFileSystems[i]);
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&RemovableDeviceNotificationsLinux::InitOnFileThread, this));
 }
 
 bool RemovableDeviceNotificationsLinux::GetDeviceInfoForPath(
     const FilePath& path,
-    base::SystemMonitor::RemovableStorageInfo* device_info) const {
+    StorageInfo* device_info) const {
   if (!path.IsAbsolute())
     return false;
 
   FilePath current = path;
   while (!ContainsKey(mount_info_map_, current) && current != current.DirName())
     current = current.DirName();
 
   MountMap::const_iterator mount_info = mount_info_map_.find(current);
   if (mount_info == mount_info_map_.end())
     return false;
@@ skipping 73 matching lines @@
     // |mount_point|.
     if (new_iter == new_mtab.end() || (new_iter->second != mount_device)) {
       MountPriorityMap::iterator priority =
           mount_priority_map_.find(mount_device);
       DCHECK(priority != mount_priority_map_.end());
       ReferencedMountPoint::const_iterator has_priority =
           priority->second.find(mount_point);
       if (MediaStorageUtil::IsRemovableDevice(old_iter->second.device_id)) {
         DCHECK(has_priority != priority->second.end());
         if (has_priority->second) {
-          base::SystemMonitor::Get()->ProcessRemovableStorageDetached(
-              old_iter->second.device_id);
+          ProcessDetach(old_iter->second.device_id);
         }
         if (priority->second.size() > 1)
           multiple_mounted_devices_needing_reattachment.push_back(mount_device);
       }
       priority->second.erase(mount_point);
       if (priority->second.empty())
         mount_priority_map_.erase(mount_device);
       mount_points_to_erase.push_back(mount_point);
     }
   }
@@ skipping 15 matching lines @@
        it != multiple_mounted_devices_needing_reattachment.end();
        ++it) {
     ReferencedMountPoint::iterator first_mount_point_info =
         mount_priority_map_.find(*it)->second.begin();
     const FilePath& mount_point = first_mount_point_info->first;
     first_mount_point_info->second = true;
 
     const MountPointInfo& mount_info =
         mount_info_map_.find(mount_point)->second;
     DCHECK(MediaStorageUtil::IsRemovableDevice(mount_info.device_id));
-    base::SystemMonitor::Get()->ProcessRemovableStorageAttached(
+    ProcessAttach(
         mount_info.device_id, mount_info.device_name, mount_point.value());
   }
 
   // Check new mtab entries against existing ones.
   for (MountPointDeviceMap::iterator new_iter = new_mtab.begin();
        new_iter != new_mtab.end(); ++new_iter) {
     const FilePath& mount_point = new_iter->first;
     const FilePath& mount_device = new_iter->second;
     MountMap::iterator old_iter = mount_info_map_.find(mount_point);
     if (old_iter == mount_info_map_.end() ||
@@ skipping 45 matching lines @@
   MountPointInfo mount_point_info;
   mount_point_info.mount_device = mount_device;
   mount_point_info.device_id = device_id;
   mount_point_info.device_name = name;
   mount_point_info.partition_size_in_bytes = partition_size_in_bytes;
 
   mount_info_map_[mount_point] = mount_point_info;
   mount_priority_map_[mount_device][mount_point] = removable;
 
   if (removable) {
-    base::SystemMonitor::Get()->ProcessRemovableStorageAttached(
+    ProcessAttach(
         device_id, GetDisplayNameForDevice(partition_size_in_bytes, name),
         mount_point.value());
   }
 }
 
-// static
-RemovableStorageNotifications* RemovableStorageNotifications::GetInstance() {
-  DCHECK(g_removable_device_notifications_linux != NULL);
-  return g_removable_device_notifications_linux;
-}
-
 }  // namespace chrome