Adds API test for imageWriterPrivate.writeFromFile

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 59 matching lines @@
 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;
   error_callback_ = error_callback;
+
+  if (!write_callback_.is_null())
+    write_callback_.Run();
 }
 
 void FakeImageWriterClient::Verify(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;
   error_callback_ = error_callback;
+
+  if (!verify_callback_.is_null())
+    verify_callback_.Run();
 }
 
 void FakeImageWriterClient::Cancel(const CancelCallback& cancel_callback) {
   cancel_callback_ = cancel_callback;
 }
 
 void FakeImageWriterClient::Shutdown() {
   // Clear handlers to not hold any reference to the caller.
-  success_callback_ = base::Closure();
-  progress_callback_ = base::Callback<void(int64)>();
-  error_callback_ = base::Callback<void(const std::string&)>();
-  cancel_callback_ = base::Closure();
+  success_callback_.Reset();
+  progress_callback_.Reset();
+  error_callback_.Reset();
+  cancel_callback_.Reset();
+
+  write_callback_.Reset();
+  verify_callback_.Reset();
+}
+
+void FakeImageWriterClient::SetWriteCallback(
+    const base::Closure& write_callback) {
+  write_callback_ = write_callback;
+}
+
+void FakeImageWriterClient::SetVerifyCallback(
+    const base::Closure& verify_callback) {
+  verify_callback_ = verify_callback;
 }
 
 void FakeImageWriterClient::Progress(int64 progress) {
-  progress_callback_.Run(progress);
+  if (!progress_callback_.is_null())
+    progress_callback_.Run(progress);
 }
 
-void FakeImageWriterClient::Success() { success_callback_.Run(); }
+void FakeImageWriterClient::Success() {
+  if (!success_callback_.is_null())
+    success_callback_.Run();
+}
 
 void FakeImageWriterClient::Error(const std::string& message) {
-  error_callback_.Run(message);
+  if (!error_callback_.is_null())
+    error_callback_.Run(message);
 }
 
-void FakeImageWriterClient::Cancel() { cancel_callback_.Run(); }
-
-scoped_refptr<FakeImageWriterClient> FakeImageWriterClient::Create() {
-  return scoped_refptr<FakeImageWriterClient>(new FakeImageWriterClient());
+void FakeImageWriterClient::Cancel() {
+  if (!cancel_callback_.is_null())
+    cancel_callback_.Run();
 }
 
-ImageWriterUnitTestBase::ImageWriterUnitTestBase()
-    : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
-ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {}
+ImageWriterTestUtils::ImageWriterTestUtils() {
+}
+ImageWriterTestUtils::~ImageWriterTestUtils() {
+}
 
-void ImageWriterUnitTestBase::SetUp() {
-  testing::Test::SetUp();
+void ImageWriterTestUtils::SetUp() {
+  SetUp(false);
+}
 
+void ImageWriterTestUtils::SetUp(bool is_browser_test) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &test_image_path_));
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &test_device_path_));
 
   ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize));
   ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize));
 
 #if defined(OS_CHROMEOS)
   if (!chromeos::DBusThreadManager::IsInitialized()) {
     chromeos::FakeDBusThreadManager* fake_dbus_thread_manager =
         new chromeos::FakeDBusThreadManager;
+    fake_dbus_thread_manager->SetFakeClients();
     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);
+
+    if (is_browser_test) {
+      chromeos::DBusThreadManager::SetInstanceForTesting(
+          fake_dbus_thread_manager);
+    } else {
+      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();
+#else
+  client_ = new FakeImageWriterClient();
+  image_writer::Operation::SetUtilityClientForTesting(client_);
 #endif
 }
 
-void ImageWriterUnitTestBase::TearDown() {
+void ImageWriterTestUtils::TearDown() {
 #if defined(OS_CHROMEOS)
-  chromeos::DBusThreadManager::Shutdown();
+  if (chromeos::DBusThreadManager::IsInitialized()) {
+    chromeos::DBusThreadManager::Shutdown();
+  }
   chromeos::disks::DiskMountManager::Shutdown();
+#else
+  image_writer::Operation::SetUtilityClientForTesting(NULL);
+  client_->Shutdown();
 #endif
 }
 
-bool ImageWriterUnitTestBase::ImageWrittenToDevice(
-    const base::FilePath& image_path,
-    const base::FilePath& device_path) {
+const base::FilePath& ImageWriterTestUtils::GetTempDir() {
+  return temp_dir_.path();
+}
+
+const base::FilePath& ImageWriterTestUtils::GetImagePath() {
+  return test_image_path_;
+}
+
+const base::FilePath& ImageWriterTestUtils::GetDevicePath() {
+  return test_device_path_;
+}
+
+#if !defined(OS_CHROMEOS)
+FakeImageWriterClient* ImageWriterTestUtils::GetUtilityClient() {
+  return client_.get();
+}
+#endif
+
+bool ImageWriterTestUtils::ImageWrittenToDevice() {
   scoped_ptr<char[]> image_buffer(new char[kTestFileSize]);
   scoped_ptr<char[]> device_buffer(new char[kTestFileSize]);
 
   int image_bytes_read =
-      ReadFile(image_path, image_buffer.get(), kTestFileSize);
+      ReadFile(test_image_path_, image_buffer.get(), kTestFileSize);
 
   if (image_bytes_read < 0)
     return false;
 
   int device_bytes_read =
-      ReadFile(device_path, device_buffer.get(), kTestFileSize);
+      ReadFile(test_device_path_, device_buffer.get(), kTestFileSize);
 
   if (image_bytes_read != device_bytes_read)
     return false;
 
   return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0;
 }
 
-bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file,
-                                       const int pattern,
-                                       const int length) {
+bool ImageWriterTestUtils::FillFile(const base::FilePath& file,
+                                    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;
 }
 
+ImageWriterUnitTestBase::ImageWriterUnitTestBase()
+    : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
+}
+ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {
+}
+
+void ImageWriterUnitTestBase::SetUp() {
+  testing::Test::SetUp();
+  test_utils_.SetUp();
+}
+
+void ImageWriterUnitTestBase::TearDown() {
+  testing::Test::TearDown();
+  test_utils_.TearDown();
+}
+
 }  // namespace image_writer
 }  // namespace extensions