Adds imageWriterPrivate support for Windows

chrome/browser/image_writer/image_writer_browsertest.cc

+// Copyright (c) 2012 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 "base/file_util.h"
+#include "base/run_loop.h"
+#include "chrome/browser/image_writer/image_writer.h"
+#include "chrome/browser/image_writer/image_writer_test_utils.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace image_writer {
+
+using testing::_;
+using testing::AnyNumber;
+using testing::AtLeast;
+using testing::Lt;
+
+namespace {
+
+class ImageWriterBrowserTest : public InProcessBrowserTest {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    temp_files_.SetUp();
+    InProcessBrowserTest::SetUp();
+  }
+
+  TempFilesForTesting temp_files_;
+};
+
+class MockImageWriterDelgate : public ImageWriter::Delegate {
+ public:
+  MOCK_METHOD0(OnWriteImageSucceeded, void());
+  MOCK_METHOD1(OnWriteImageFailed, void(const std::string& message));
+  MOCK_METHOD1(OnWriteImageProgress, void(int progress));
+};
+
+class QuittingDelegate : public ImageWriter::Delegate {
+ public:
+  QuittingDelegate(const base::Closure& quit_closure,
+                   ImageWriter::Delegate* delegate)
+      : quit_closure_(quit_closure),
+        delegate_(delegate) {
+  }
+
+  virtual void OnWriteImageSucceeded() OVERRIDE {
+    content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                     FROM_HERE,
+                                     quit_closure_);
+    delegate_->OnWriteImageSucceeded();
+  }
+
+  virtual void OnWriteImageFailed(const std::string& message) OVERRIDE {
+    content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                     FROM_HERE,
+                                     quit_closure_);
+    delegate_->OnWriteImageFailed(message);
+  }
+
+  virtual void OnWriteImageProgress(int progress) OVERRIDE {
+    delegate_->OnWriteImageProgress(progress);
+  }
+
+ private:
+  base::Closure quit_closure_;
+  ImageWriter::Delegate* delegate_;
+};
+
+} // namespace
+
+IN_PROC_BROWSER_TEST_F(ImageWriterBrowserTest, Successful) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  DLOG(INFO) << "Test starting.";
+
+  base::RunLoop loop;
+
+  MockImageWriterDelgate mock_delegate;
+  QuittingDelegate delegate(loop.QuitClosure(), &mock_delegate);
+
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(&delegate,
+                      temp_files_.ImagePath(),
+                      temp_files_.DevicePath()));
+
+  EXPECT_CALL(mock_delegate, OnWriteImageProgress(Lt(100))).Times(AnyNumber());
+  EXPECT_CALL(mock_delegate, OnWriteImageProgress(100)).Times(AtLeast(1));
+  EXPECT_CALL(mock_delegate, OnWriteImageSucceeded()).Times(1);
+  EXPECT_CALL(mock_delegate, OnWriteImageFailed(_)).Times(0);
+
+  temp_files_.InitializeImage();
+  image_writer->Start(base::MessageLoop::current()->message_loop_proxy());
+
+  loop.Run();
+
+  EXPECT_TRUE(temp_files_.CompareImageAndDevice());
+
+  DLOG(INFO) << "Test complete.";
+}
+
+}  // namespace image_writer