Storage Monitor: Make StorageMonitorLinux own the MediaTransferProtocolManager.

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/command_line.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_storage_util.h"
 #include "chrome/browser/storage_monitor/media_transfer_protocol_device_observer_linux.h"
 #include "chrome/browser/storage_monitor/removable_device_constants.h"
+#include "chrome/browser/storage_monitor/test_media_transfer_protocol_manager_linux.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 
 namespace chromeos {
 
 namespace {
 
 // Constructs a device name using label or manufacturer (vendor and product)
 // name details.
@@ skipping 81 matching lines @@
       base::FilePath(mount_info.mount_path));
 }
 
 }  // namespace
 
 using content::BrowserThread;
 using chrome::StorageInfo;
 
 StorageMonitorCros::StorageMonitorCros()
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+  // TODO(thestig) Do not do this here. Do it in TestingBrowserProcess when
+  // BrowserProcess owns StorageMonitor.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
+    SetMediaTransferProtocolManagerForTest(
+        new chrome::TestMediaTransferProtocolManagerLinux());
+  }
 }
 
 StorageMonitorCros::~StorageMonitorCros() {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
-    device::MediaTransferProtocolManager::Shutdown();
-  }
-
   disks::DiskMountManager* manager = disks::DiskMountManager::GetInstance();
   if (manager) {
     manager->RemoveObserver(this);
   }
 }
 
 void StorageMonitorCros::Init() {
   DCHECK(disks::DiskMountManager::GetInstance());
   disks::DiskMountManager::GetInstance()->AddObserver(this);
   CheckExistingMountPoints();
 
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
+  if (!media_transfer_protocol_manager_) {
     scoped_refptr<base::MessageLoopProxy> loop_proxy;
-    device::MediaTransferProtocolManager::Initialize(loop_proxy);
+    media_transfer_protocol_manager_.reset(
+        device::MediaTransferProtocolManager::Initialize(loop_proxy));
+  }
 
-    media_transfer_protocol_device_observer_.reset(
-        new chrome::MediaTransferProtocolDeviceObserverLinux(receiver()));
-  }
+  media_transfer_protocol_device_observer_.reset(
+      new chrome::MediaTransferProtocolDeviceObserverLinux(receiver()));
 }
 
 void StorageMonitorCros::CheckExistingMountPoints() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const disks::DiskMountManager::MountPointMap& mount_point_map =
       disks::DiskMountManager::GetInstance()->mount_points();
   for (disks::DiskMountManager::MountPointMap::const_iterator it =
            mount_point_map.begin(); it != mount_point_map.end(); ++it) {
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::FILE, FROM_HERE,
@@ skipping 52 matching lines @@
     }
   }
 }
 
 void StorageMonitorCros::OnFormatEvent(
     disks::DiskMountManager::FormatEvent event,
     FormatError error_code,
     const std::string& device_path) {
 }
 
+void StorageMonitorCros::SetMediaTransferProtocolManagerForTest(
+    device::MediaTransferProtocolManager* test_manager) {
+  DCHECK(!media_transfer_protocol_manager_);
+  media_transfer_protocol_manager_.reset(test_manager);
+}
+
+
 bool StorageMonitorCros::GetStorageInfoForPath(
     const base::FilePath& path,
     StorageInfo* device_info) const {
-  // TODO(thestig) |media_transfer_protocol_device_observer_| should always be
-  // valid.
-  if (media_transfer_protocol_device_observer_ &&
-      media_transfer_protocol_device_observer_->GetStorageInfoForPath(
+  if (media_transfer_protocol_device_observer_->GetStorageInfoForPath(
           path, device_info)) {
     return true;
   }
 
   if (!path.IsAbsolute())
     return false;
 
   base::FilePath current = path;
   while (!ContainsKey(mount_map_, current.value()) &&
          current != current.DirName()) {
@@ skipping 38 matching lines @@
   disks::DiskMountManager* manager = disks::DiskMountManager::GetInstance();
   if (!manager) {
     callback.Run(EJECT_FAILURE);
     return;
   }
 
   manager->UnmountPath(mount_path, chromeos::UNMOUNT_OPTIONS_NONE,
                        base::Bind(NotifyUnmountResult, callback));
 }
 
+device::MediaTransferProtocolManager*
+StorageMonitorCros::media_transfer_protocol_manager() {
+  return media_transfer_protocol_manager_.get();
+}
+
 void StorageMonitorCros::AddMountedPath(
     const disks::DiskMountManager::MountPointInfo& mount_info, bool has_dcim) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (ContainsKey(mount_map_, mount_info.mount_path)) {
     // CheckExistingMountPointsOnUIThread() added the mount point information
     // in the map before the device attached handler is called. Therefore, an
     // entry for the device already exists in the map.
     return;
   }
@@ skipping 33 matching lines @@
       vendor_name,
       model_name,
       storage_size_in_bytes);
 
   mount_map_.insert(std::make_pair(mount_info.mount_path, object_info));
 
   receiver()->ProcessAttach(object_info);
 }
 
 }  // namespace chromeos