Add a receiver interface to RemovableStorageNotifications.

chrome/browser/system_monitor/portable_device_watcher_win.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.
 //
 // Any tasks that communicates with the portable device may take >100ms to
 // complete. Those tasks should be run on an blocking thread instead of the
 // UI thread.
 
 #include "chrome/browser/system_monitor/portable_device_watcher_win.h"
 
@@ skipping 460 matching lines @@
 
 PortableDeviceWatcherWin::DeviceStorageObject::DeviceStorageObject(
     const string16& temporary_id,
     const std::string& persistent_id)
     : object_temporary_id(temporary_id),
       object_persistent_id(persistent_id) {
 }
 
 PortableDeviceWatcherWin::PortableDeviceWatcherWin()
     : notifications_(NULL),
+      storage_notifications_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 PortableDeviceWatcherWin::~PortableDeviceWatcherWin() {
   UnregisterDeviceNotification(notifications_);
 }
 
 void PortableDeviceWatcherWin::Init(HWND hwnd) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   notifications_ = RegisterPortableDeviceNotification(hwnd);
@@ skipping 47 matching lines @@
 
 // static
 string16 PortableDeviceWatcherWin::GetStoragePathFromStorageId(
     const std::string& storage_unique_id) {
   // Construct a dummy device path using the storage name. This is only used
   // for registering the device media file system.
   DCHECK(!storage_unique_id.empty());
   return UTF8ToUTF16("\\\\" + storage_unique_id);
 }
 
+void PortableDeviceWatcherWin::SetNotifications(
+    RemovableStorageNotifications::Receiver* notifications) {
+  storage_notifications_ = notifications;
+}
+
 void PortableDeviceWatcherWin::EnumerateAttachedDevices() {
   DCHECK(media_task_runner_.get());
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   Devices* devices = new Devices;
   base::PostTaskAndReplyWithResult(
       media_task_runner_,
       FROM_HERE,
       base::Bind(&EnumerateAttachedDevicesOnBlockingThread, devices),
       base::Bind(&PortableDeviceWatcherWin::OnDidEnumerateAttachedDevices,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(devices)));
@@ skipping 29 matching lines @@
     const DeviceDetails* device_details, const bool result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(device_details);
   if (!result)
     return;
 
   const StorageObjects& storage_objects = device_details->storage_objects;
   const string16& name = device_details->name;
   const string16& location = device_details->location;
   DCHECK(!ContainsKey(device_map_, location));
-  RemovableStorageNotifications* notifications =
-      RemovableStorageNotifications::GetInstance();
-  DCHECK(notifications);
   for (StorageObjects::const_iterator storage_iter = storage_objects.begin();
        storage_iter != storage_objects.end(); ++storage_iter) {
     const std::string& storage_id = storage_iter->object_persistent_id;
     DCHECK(!ContainsKey(storage_map_, storage_id));
 
     // Keep track of storage id and storage name to see how often we receive
     // empty values.
     MediaStorageUtil::RecordDeviceInfoHistogram(false, storage_id, name);
     if (storage_id.empty() || name.empty())
       return;
 
     // Device can have several data partitions. Therefore, add the
     // partition identifier to the storage name. E.g.: "Nexus 7 (s10001)"
     string16 storage_name(name + L" (" + storage_iter->object_temporary_id +
         L')');
     storage_map_[storage_id] = RemovableStorageNotifications::StorageInfo(
         storage_id, storage_name, location);
-    notifications->ProcessAttach(
-        storage_id, storage_name, GetStoragePathFromStorageId(storage_id));
+    if (storage_notifications_) {
+      storage_notifications_->ProcessAttach(
+          storage_id, storage_name,
+          GetStoragePathFromStorageId(storage_id));
+    }
   }
   device_map_[location] = storage_objects;
 }
 
 void PortableDeviceWatcherWin::HandleDeviceDetachEvent(
     const string16& pnp_device_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   MTPDeviceMap::iterator device_iter = device_map_.find(pnp_device_id);
   if (device_iter == device_map_.end())
     return;
 
-  RemovableStorageNotifications* notifications =
-      RemovableStorageNotifications::GetInstance();
-  DCHECK(notifications);
-
   const StorageObjects& storage_objects = device_iter->second;
   for (StorageObjects::const_iterator storage_object_iter =
        storage_objects.begin(); storage_object_iter != storage_objects.end();
        ++storage_object_iter) {
     std::string storage_id = storage_object_iter->object_persistent_id;
     MTPStorageMap::iterator storage_map_iter = storage_map_.find(storage_id);
     DCHECK(storage_map_iter != storage_map_.end());
-    notifications->ProcessDetach(storage_map_iter->second.device_id);
+    if (storage_notifications_)
+      storage_notifications_->ProcessDetach(storage_map_iter->second.device_id);
     storage_map_.erase(storage_map_iter);
   }
   device_map_.erase(device_iter);
 }
 
 }  // namespace chrome