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 33 matching lines @@
 
  private:
   BurnFinishedHandler burn_finished_handler_;
   BurnProgressUpdateHandler burn_progress_update_handler_;
 
 };
 
 } // namespace
 #endif
 
+QuittingMockManager::QuittingMockManager(const base::Closure& quit_closure)
+    : quit_closure_(quit_closure) {}
+
+void QuittingMockManager::OnComplete(const ExtensionId& extension_id) {
+  MockOperationManager::OnComplete(extension_id);
+  quit_closure_.Run();
+}
+
+void QuittingMockManager::OnError(const ExtensionId& extension_id,
+                                  image_writer_api::Stage stage,
+                                  int progress,
+                                  const std::string& error_message) {
+  MockOperationManager::OnError(extension_id, stage, progress, error_message);
+  quit_closure_.Run();
+}
+
 MockOperationManager::MockOperationManager() : OperationManager(NULL) {}
 MockOperationManager::~MockOperationManager() {}
 
-ImageWriterUnitTestBase::ImageWriterUnitTestBase() {}
+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::CompareImageAndDevice() {
+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]);
 
-  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);
+  int image_bytes_read =
+      ReadFile(image_path, image_buffer.get(), kTestFileSize);
 
-    if (image_bytes_read != device_bytes_read)
-      return false;
+  if (image_bytes_read == 0)

[Lei Zhang, 2014/02/15 01:07:26]

This can't happen when you have requested 32 KB.

[Drew Haven, 2014/02/15 02:15:15]

Done.

+    // Trivially true.
+    return true;
 
-    if (image_bytes_read == 0)
-      return true;
+  if (image_bytes_read < 0)
+    return false;
 
-    if (memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) != 0)
-      return false;
-  }
+  int device_bytes_read =
+      ReadFile(device_path, device_buffer.get(), kTestFileSize);
 
-  return false;
+  if (image_bytes_read != device_bytes_read)
+    return false;
+
+  return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0;

[Jorge Lucangeli Obes, 2014/02/15 01:43:19]

This is converting signed -> size_t, but at least we have the >= check above.

[Drew Haven, 2014/02/15 02:15:15]

Good point.  How convinient that ReadFile takes an int and so cannot read more
than fits in a signed int.

 }
 
 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