components/storage_monitor/test_storage_monitor.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/storage_monitor/test_storage_monitor.h"
   6
   7 #include "base/run_loop.h"
   8 #include "base/synchronization/waitable_event.h"
   9 #include "components/storage_monitor/storage_info.h"
  10
  11 #if defined(OS_LINUX)
  12 #include "components/storage_monitor/test_media_transfer_protocol_manager_linux.h"
  13 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h"
  14 #endif
  15
  16 namespace storage_monitor {
  17
  18 TestStorageMonitor::TestStorageMonitor()
  19     : StorageMonitor(),
  20       init_called_(false) {
  21 #if defined(OS_LINUX)
  22   media_transfer_protocol_manager_.reset(
  23       new TestMediaTransferProtocolManagerLinux());
  24 #endif
  25 }
  26
  27 TestStorageMonitor::~TestStorageMonitor() {}
  28
  29 // static
  30 TestStorageMonitor* TestStorageMonitor::CreateAndInstall() {
  31   TestStorageMonitor* monitor = new TestStorageMonitor();
  32   scoped_ptr<StorageMonitor> pass_monitor(monitor);
  33   monitor->Init();
  34   monitor->MarkInitialized();
  35
  36   if (StorageMonitor::GetInstance() == NULL) {
  37     StorageMonitor::SetStorageMonitorForTesting(pass_monitor.Pass());
  38     return monitor;
  39   }
  40
  41   return NULL;
  42 }
  43
  44 // static
  45 TestStorageMonitor* TestStorageMonitor::CreateForBrowserTests() {
  46   TestStorageMonitor* monitor = new TestStorageMonitor();
  47   monitor->Init();
  48   monitor->MarkInitialized();
  49
  50   scoped_ptr<StorageMonitor> pass_monitor(monitor);
  51   StorageMonitor::SetStorageMonitorForTesting(pass_monitor.Pass());
  52
  53   return monitor;
  54 }
  55
  56 // static
  57 void TestStorageMonitor::SyncInitialize() {
  58   StorageMonitor* monitor = StorageMonitor::GetInstance();
  59   if (monitor->IsInitialized())
  60     return;
  61
  62   base::WaitableEvent event(true, false);
  63   monitor->EnsureInitialized(base::Bind(&base::WaitableEvent::Signal,
  64                              base::Unretained(&event)));
  65   while (!event.IsSignaled()) {
  66     base::RunLoop().RunUntilIdle();
  67   }
  68   DCHECK(monitor->IsInitialized());
  69 }
  70
  71 void TestStorageMonitor::Init() {
  72   init_called_ = true;
  73 }
  74
  75 void TestStorageMonitor::MarkInitialized() {
  76   StorageMonitor::MarkInitialized();
  77 }
  78
  79 bool TestStorageMonitor::GetStorageInfoForPath(
  80     const base::FilePath& path,
  81     StorageInfo* device_info) const {
  82   DCHECK(device_info);
  83
  84   if (!path.IsAbsolute())
  85     return false;
  86
  87   std::string device_id = StorageInfo::MakeDeviceId(
  88       StorageInfo::FIXED_MASS_STORAGE, path.AsUTF8Unsafe());
  89   *device_info =
  90       StorageInfo(device_id, path.value(), base::string16(), base::string16(),
  91                   base::string16(), 0);
  92   return true;
  93 }
  94
  95 #if defined(OS_WIN)
  96 bool TestStorageMonitor::GetMTPStorageInfoFromDeviceId(
  97     const std::string& storage_device_id,
  98     base::string16* device_location,
  99     base::string16* storage_object_id) const {
 100   return false;
 101 }
 102 #endif
 103
 104 #if defined(OS_LINUX)
 105 device::MediaTransferProtocolManager*
 106 TestStorageMonitor::media_transfer_protocol_manager() {
 107   return media_transfer_protocol_manager_.get();
 108 }
 109 #endif
 110
 111 StorageMonitor::Receiver* TestStorageMonitor::receiver() const {
 112   return StorageMonitor::receiver();
 113 }
 114
 115 void TestStorageMonitor::EjectDevice(
 116     const std::string& device_id,
 117     base::Callback<void(EjectStatus)> callback) {
 118   ejected_device_ = device_id;
 119   callback.Run(EJECT_OK);
 120 }
 121
 122 }  // namespace storage_monitor