Unmounts volumes before writing to a drive.

chrome/browser/extensions/api/image_writer_private/test_utils.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_dbus_thread_manager.h"
 #include "chromeos/dbus/fake_image_burner_client.h"
@@ skipping 37 matching lines @@
 };
 
 } // namespace
 #endif
 
 MockOperationManager::MockOperationManager() : OperationManager(NULL) {}
 MockOperationManager::MockOperationManager(content::BrowserContext* context)
     : OperationManager(context) {}
 MockOperationManager::~MockOperationManager() {}
 
+#if defined(OS_CHROMEOS)
+FakeDiskMountManager::FakeDiskMountManager() {}
+FakeDiskMountManager::~FakeDiskMountManager() {}
+
+void FakeDiskMountManager::UnmountDeviceRecursively(
+    const std::string& device_path,
+    const UnmountDeviceRecursivelyCallbackType& callback) {
+  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true));
+}
+#endif
+
 FakeImageWriterClient::FakeImageWriterClient() {}
 FakeImageWriterClient::~FakeImageWriterClient() {}
 
 void FakeImageWriterClient::Write(const ProgressCallback& progress_callback,
                                   const SuccessCallback& success_callback,
                                   const ErrorCallback& error_callback,
                                   const base::FilePath& source,
                                   const base::FilePath& target) {
   progress_callback_ = progress_callback;
   success_callback_ = success_callback;
@@ skipping 56 matching lines @@
 
 #if defined(OS_CHROMEOS)
   if (!chromeos::DBusThreadManager::IsInitialized()) {
     chromeos::FakeDBusThreadManager* fake_dbus_thread_manager =
         new chromeos::FakeDBusThreadManager;
     scoped_ptr<chromeos::ImageBurnerClient>
         image_burner_fake(new ImageWriterFakeImageBurnerClient());
     fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass());
     chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager);
   }
+  FakeDiskMountManager* disk_manager = new FakeDiskMountManager();
+  chromeos::disks::DiskMountManager::InitializeForTesting(disk_manager);
+
+  // Adds a disk entry for test_device_path_ with the same device and file path.
+  disk_manager->CreateDiskEntryForMountDevice(
+      chromeos::disks::DiskMountManager::MountPointInfo(
+          test_device_path_.value(),
+          "/dummy/mount",
+          chromeos::MOUNT_TYPE_DEVICE,
+          chromeos::disks::MOUNT_CONDITION_NONE),
+      "device_id",
+      "device_label",
+      "Vendor",
+      "Product",
+      chromeos::DEVICE_TYPE_USB,
+      kTestFileSize,
+      true,
+      true,
+      false);
+  disk_manager->SetupDefaultReplies();
 #endif
 }
 
 void ImageWriterUnitTestBase::TearDown() {
 #if defined(OS_CHROMEOS)
   chromeos::DBusThreadManager::Shutdown();
+  chromeos::disks::DiskMountManager::Shutdown();
 #endif
 }
 
 bool ImageWriterUnitTestBase::ImageWrittenToDevice(
     const base::FilePath& image_path,
     const base::FilePath& device_path) {
   scoped_ptr<char[]> image_buffer(new char[kTestFileSize]);
   scoped_ptr<char[]> device_buffer(new char[kTestFileSize]);
 
   int image_bytes_read =
@@ skipping 15 matching lines @@
                                        const int pattern,
                                        const int length) {
   scoped_ptr<char[]> buffer(new char[length]);
   memset(buffer.get(), pattern, length);
 
   return base::WriteFile(file, buffer.get(), length) == length;
 }
 
 }  // namespace image_writer
 }  // namespace extensions