Storage Monitor: Make StorageMonitorLinux own the MediaTransferProtocolManager.

chrome/browser/storage_monitor/storage_monitor_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.
 
 // StorageMonitorLinux implementation.
 
 #include "chrome/browser/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.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/browser/storage_monitor/udev_util_linux.h"
 #include "chrome/common/chrome_switches.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 
 namespace chrome {
 
 using content::BrowserThread;
 typedef MtabWatcherLinux::MountPointDeviceMap MountPointDeviceMap;
 
 namespace {
@@ skipping 190 matching lines @@
   return new MtabWatcherLinux(mtab_path, delegate);
 }
 
 }  // namespace
 
 StorageMonitorLinux::StorageMonitorLinux(const base::FilePath& path)
     : mtab_path_(path),
       get_device_info_callback_(base::Bind(&GetDeviceInfo)),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // TODO(thestig) Do not do this here. Do it in TestingBrowserProcess when
+  // BrowserProcess owns StorageMonitor.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
+    SetMediaTransferProtocolManagerForTest(
+        new TestMediaTransferProtocolManagerLinux());
+  }
 }
 
 StorageMonitorLinux::~StorageMonitorLinux() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType))
-    device::MediaTransferProtocolManager::Shutdown();
 }
 
 void StorageMonitorLinux::Init() {
   DCHECK(!mtab_path_.empty());
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateMtabWatcherLinuxOnFileThread,
                  mtab_path_,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&StorageMonitorLinux::OnMtabWatcherCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
-    scoped_refptr<base::MessageLoopProxy> loop_proxy;
-    loop_proxy = content::BrowserThread::GetMessageLoopProxyForThread(
-        content::BrowserThread::FILE);
-    device::MediaTransferProtocolManager::Initialize(loop_proxy);
+  if (!media_transfer_protocol_manager_) {
+    scoped_refptr<base::MessageLoopProxy> loop_proxy =
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
+    media_transfer_protocol_manager_.reset(
+        device::MediaTransferProtocolManager::Initialize(loop_proxy));
+  }
 
-    media_transfer_protocol_device_observer_.reset(
-        new MediaTransferProtocolDeviceObserverLinux(receiver()));
-  }
+  media_transfer_protocol_device_observer_.reset(
+      new MediaTransferProtocolDeviceObserverLinux(receiver()));
 }
 
 bool StorageMonitorLinux::GetStorageInfoForPath(
     const base::FilePath& path,
     StorageInfo* device_info) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // TODO(thestig) |media_transfer_protocol_device_observer_| should always be
   // valid.
   if (media_transfer_protocol_device_observer_ &&
@@ skipping 10 matching lines @@
     current = current.DirName();
 
   MountMap::const_iterator mount_info = mount_info_map_.find(current);
   if (mount_info == mount_info_map_.end())
     return false;
   if (device_info)
     *device_info = mount_info->second.storage_info;
   return true;
 }
 
+device::MediaTransferProtocolManager*
+StorageMonitorLinux::media_transfer_protocol_manager() {
+  return media_transfer_protocol_manager_.get();
+}
+
 void StorageMonitorLinux::SetGetDeviceInfoCallbackForTest(
     const GetDeviceInfoCallback& get_device_info_callback) {
   get_device_info_callback_ = get_device_info_callback;
 }
 
+void StorageMonitorLinux::SetMediaTransferProtocolManagerForTest(
+    device::MediaTransferProtocolManager* test_manager) {
+  DCHECK(!media_transfer_protocol_manager_);
+  media_transfer_protocol_manager_.reset(test_manager);
+}
+
 void StorageMonitorLinux::OnMtabWatcherCreated(MtabWatcherLinux* watcher) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   mtab_watcher_.reset(watcher);
 }
 
 void StorageMonitorLinux::UpdateMtab(const MountPointDeviceMap& new_mtab) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check existing mtab entries for unaccounted mount points.
   // These mount points must have been removed in the new mtab.
@@ skipping 120 matching lines @@
 
   if (removable) {
     // TODO(gbillock) Do this in a higher level instead of here.
     storage_info->name = MediaStorageUtil::GetDisplayNameForDevice(
         storage_info->total_size_in_bytes, storage_info->name);
     receiver()->ProcessAttach(*storage_info);
   }
 }
 
 }  // namespace chrome