Adds imageWriterPrivate support for Windows

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(Profile* profile)
     : OperationManager(profile) {}
 MockOperationManager::~MockOperationManager() {}
 
+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;
+  error_callback_ = error_callback;
+}
+
+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;
+}
+
+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();
+}
+
+void FakeImageWriterClient::Progress(int64 progress) {
+  progress_callback_.Run(progress);
+}
+
+void FakeImageWriterClient::Success() { success_callback_.Run(); }
+
+void FakeImageWriterClient::Error(const std::string& message) {
+  error_callback_.Run(message);
+}
+
+void FakeImageWriterClient::Cancel() { cancel_callback_.Run(); }
+
+scoped_refptr<FakeImageWriterClient> FakeImageWriterClient::Create() {
+  return scoped_refptr<FakeImageWriterClient>(new FakeImageWriterClient());
+}
+
 ImageWriterUnitTestBase::ImageWriterUnitTestBase()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
 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
 }
 
 void ImageWriterUnitTestBase::TearDown() {
 #if defined(OS_CHROMEOS)
   chromeos::DBusThreadManager::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 =
+      ReadFile(image_path, image_buffer.get(), kTestFileSize);
+
+  if (image_bytes_read < 0)
+    return false;
+
+  int device_bytes_read =
+      ReadFile(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) {
   scoped_ptr<char[]> buffer(new char[length]);
   memset(buffer.get(), pattern, length);
 
   return file_util::WriteFile(file, buffer.get(), length) == length;
 }
 
 }  // namespace image_writer
 }  // namespace extensions