Revert of Significantly cleans up the ImageWriter Operation class and subclasses.

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 27 matching lines @@
         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) {}
-MockOperationManager::MockOperationManager(Profile* profile)
-    : OperationManager(profile) {}
 MockOperationManager::~MockOperationManager() {}
 
-ImageWriterUnitTestBase::ImageWriterUnitTestBase()
-    : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
+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_));
@@ skipping 12 matching lines @@
   }
 #endif
 }
 
 void ImageWriterUnitTestBase::TearDown() {
 #if defined(OS_CHROMEOS)
   chromeos::DBusThreadManager::Shutdown();
 #endif
 }
 
+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;
+}
+
 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