Adds ImageWriterPrivate.destroyPartitions operation.

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"
+#endif
+
 namespace extensions {
 namespace image_writer {
 
+#if defined(OS_CHROMEOS)
+namespace {
+
+class ImageWriterFakeImageBurnerClient
+    : public chromeos::FakeImageBurnerClient {
+ public:
+  ImageWriterFakeImageBurnerClient() {}
+  virtual ~ImageWriterFakeImageBurnerClient() {}
+
+  virtual void SetEventHandlers(
+      const BurnFinishedHandler& burn_finished_handler,
+      const BurnProgressUpdateHandler& burn_progress_update_handler) OVERRIDE {
+    burn_finished_handler_ = burn_finished_handler;
+    burn_progress_update_handler_ = burn_progress_update_handler;
+  }
+
+  virtual void BurnImage(const std::string& from_path,
+                         const std::string& to_path,
+                         const ErrorCallback& error_callback) OVERRIDE {
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(burn_progress_update_handler_, to_path, 0, 100));
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(burn_progress_update_handler_, to_path, 50, 100));
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(burn_progress_update_handler_, to_path, 100, 100));
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(burn_finished_handler_, to_path, true, ""));
+  }
+
+ private:
+  BurnFinishedHandler burn_finished_handler_;
+  BurnProgressUpdateHandler burn_progress_update_handler_;
+
+};
+
+} // namespace
+#endif
+
 MockOperationManager::MockOperationManager()
-    : OperationManager(NULL) {
+    : OperationManager(NULL) {}
+
+MockOperationManager::~MockOperationManager() {}
+
+ImageWriterUnitTestBase::ImageWriterUnitTestBase() {}
+ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {}
+
+void ImageWriterUnitTestBase::SetUp() {
+  testing::Test::SetUp();
+  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;
+    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);
+  }
+#endif
 }
 
-MockOperationManager::~MockOperationManager() {
+void ImageWriterUnitTestBase::TearDown() {}
+
+bool ImageWriterUnitTestBase::CompareImageAndDevice() {
+  scoped_ptr<char[]> image_buffer(new char[kTestFileSize]);
+  scoped_ptr<char[]> device_buffer(new char[kTestFileSize]);
+
+  while (true) {
+    int image_bytes_read = ReadFile(test_image_path_,
+                                    image_buffer.get(),
+                                    kTestFileSize);
+    int device_bytes_read = ReadFile(test_device_path_,
+                                     device_buffer.get(),
+                                     kTestFileSize);
+
+    if (image_bytes_read != device_bytes_read)
+      return false;
+
+    if (image_bytes_read == 0)
+      return true;
+
+    if (memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) != 0)
+      return false;
+  }
+
+  return false;
 }
 
-void ImageWriterUnitTestBase::SetUp() {
-  ASSERT_TRUE(base::CreateTemporaryFile(&test_image_));
-  ASSERT_TRUE(base::CreateTemporaryFile(&test_device_));
+bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file,
+                                       const int pattern,
+                                       const int length) {
+  scoped_ptr<char[]> buffer(new char[length]);
+  memset(buffer.get(), pattern, length);
 
-  ASSERT_EQ(32, file_util::WriteFile(test_image_, kTestData, 32));
-}
-
-void ImageWriterUnitTestBase::TearDown() {
-  base::DeleteFile(test_image_, false);
-  base::DeleteFile(test_device_, false);
+  return file_util::WriteFile(file, buffer.get(), length) == length;
 }
 
 }  // namespace image_writer
 }  // namespace extensions