Adds imageWriterPrivate support for Windows

chrome/utility/image_writer/image_writer_handler.cc

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this image code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/common/chrome_utility_messages.h"
+#include "chrome/utility/image_writer/error_messages.h"
+#include "chrome/utility/image_writer/image_writer.h"
+#include "chrome/utility/image_writer/image_writer_handler.h"
+#include "content/public/utility/utility_thread.h"
+
+namespace chrome {
+namespace image_writer {
+
+ImageWriterHandler::ImageWriterHandler() : weak_factory_(this) {}
+
+ImageWriterHandler::~ImageWriterHandler() {}
+
+void ImageWriterHandler::SendSucceeded() {
+  Send(new ChromeUtilityHostMsg_ImageWriter_Succeeded());
+  image_writer_ = NULL;
+  content::UtilityThread::Get()->ReleaseProcessIfNeeded();
+}
+
+void ImageWriterHandler::SendCancelled() {
+  Send(new ChromeUtilityHostMsg_ImageWriter_Cancelled());
+  image_writer_ = NULL;
+  content::UtilityThread::Get()->ReleaseProcessIfNeeded();
+}
+
+void ImageWriterHandler::SendFailed(const std::string& message) {
+  Send(new ChromeUtilityHostMsg_ImageWriter_Failed(message));
+  image_writer_ = NULL;
+  content::UtilityThread::Get()->ReleaseProcessIfNeeded();
+}
+
+void ImageWriterHandler::SendProgress(int64 progress) {
+  Send(new ChromeUtilityHostMsg_ImageWriter_Progress(progress));
+}
+
+void ImageWriterHandler::Send(IPC::Message* msg) {
+  content::UtilityThread::Get()->Send(msg);
+}
+
+bool ImageWriterHandler::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ImageWriterHandler, message)
+  IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ImageWriter_Write, OnWriteStart)
+  IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ImageWriter_Verify, OnVerifyStart)
+  IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ImageWriter_Cancel, OnCancel)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void ImageWriterHandler::OnWriteStart(const base::FilePath& image,
+                                      const base::FilePath& device) {
+  if (image_writer_ != NULL) {
+    SendFailed(error::kOperationAlreadyInProgress);

[Matt Perry, 2014/02/14 00:16:23]

This will cancel the in-progress operation. Would it make more sense to let fail
the duplicate operation, but allow the current one to complete?

[Drew Haven, 2014/02/14 02:32:56]

Good catch.  I completely missed that!

+    return;
+  }
+  image_writer_ = new ImageWriter(weak_factory_.GetWeakPtr());
+  image_writer_->Write(image, device);
+}
+
+void ImageWriterHandler::OnVerifyStart(const base::FilePath& image,
+                                       const base::FilePath& device) {
+  if (image_writer_ != NULL) {
+    SendFailed(error::kOperationAlreadyInProgress);
+    return;
+  }
+  image_writer_ = new ImageWriter(weak_factory_.GetWeakPtr());
+  image_writer_->Verify(image, device);
+}
+
+void ImageWriterHandler::OnCancel() {
+  if (image_writer_) {
+    image_writer_->Cancel();
+  } else {
+    SendCancelled();
+  }
+}
+
+}  // namespace image_writer
+}  // namespace chrome