Convert utility process ImageWriter IPC to mojo

chrome/utility/image_writer/image_writer_handler.cc

 // Copyright 2014 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/utility/image_writer/image_writer_handler.h"
 
+#include "base/bind.h"
 #include "base/files/file_path.h"
-#include "chrome/common/extensions/chrome_utility_extensions_messages.h"
+#include "base/optional.h"
+#include "chrome/common/extensions/removable_storage_writer.mojom.h"
 #include "chrome/utility/image_writer/error_messages.h"
-#include "content/public/utility/utility_thread.h"
 
 namespace image_writer {
 

[Sam McNally, 2017/02/02 21:54:17]

namespace {

[Noel Gordon, 2017/02/03 13:54:57]

Done.

-ImageWriterHandler::ImageWriterHandler() {}
-ImageWriterHandler::~ImageWriterHandler() {}
-
-void ImageWriterHandler::SendSucceeded() {
-  Send(new ChromeUtilityHostMsg_ImageWriter_Succeeded());
-  content::UtilityThread::Get()->ReleaseProcessIfNeeded();
+inline bool IsTestDevice(const base::FilePath& device) {

[Sam McNally, 2017/02/02 21:54:17]

inline is not required.

[Noel Gordon, 2017/02/03 13:54:56]

Done.

+  return device.AsUTF8Unsafe() ==
+         extensions::mojom::RemovableStorageWriter::kTestDevice;
 }
 
-void ImageWriterHandler::SendCancelled() {
-  Send(new ChromeUtilityHostMsg_ImageWriter_Cancelled());
-  content::UtilityThread::Get()->ReleaseProcessIfNeeded();
+base::FilePath MakeTestDevicePath(const base::FilePath& image) {
+  return image.ReplaceExtension(FILE_PATH_LITERAL("out"));
 }
 

[Sam McNally, 2017/02/02 21:54:17]

}  // namespace

[Noel Gordon, 2017/02/03 13:54:56]

Done.

-void ImageWriterHandler::SendFailed(const std::string& message) {
-  Send(new ChromeUtilityHostMsg_ImageWriter_Failed(message));
-  content::UtilityThread::Get()->ReleaseProcessIfNeeded();
-}
+ImageWriterHandler::ImageWriterHandler() = default;
 
-void ImageWriterHandler::SendProgress(int64_t progress) {
-  Send(new ChromeUtilityHostMsg_ImageWriter_Progress(progress));
-}
+ImageWriterHandler::~ImageWriterHandler() = default;
 
-void ImageWriterHandler::Send(IPC::Message* msg) {
-  content::UtilityThread::Get()->Send(msg);
-}
+void ImageWriterHandler::Write(
+    const base::FilePath& image,
+    const base::FilePath& device,
+    extensions::mojom::RemovableStorageWriterClientPtr client) {
+  client_ = std::move(client);
+  client_.set_connection_error_handler(
+      base::Bind(&ImageWriterHandler::Cancel, base::Unretained(this)));
 
-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;
-}
+  base::FilePath target_device = device;
+  const bool test_mode = IsTestDevice(device);
+  if (test_mode)
+    target_device = MakeTestDevicePath(image);
 
-void ImageWriterHandler::OnWriteStart(const base::FilePath& image,
-                                      const base::FilePath& device) {
+  // http://crbug.com/352442
   if (!image_writer_.get() || image != image_writer_->GetImagePath() ||
-      device != image_writer_->GetDevicePath()) {
-    image_writer_.reset(new ImageWriter(this, image, device));
+      target_device != image_writer_->GetDevicePath()) {
+    image_writer_.reset(new ImageWriter(this, image, target_device));
   }
 
   if (image_writer_->IsRunning()) {
     SendFailed(error::kOperationAlreadyInProgress);
     return;
   }
 
+  if (test_mode) {
+    image_writer_->Write();
+    return;
+  }
+
   if (!image_writer_->IsValidDevice()) {
     SendFailed(error::kInvalidDevice);
     return;
   }
 
   image_writer_->UnmountVolumes(
       base::Bind(&ImageWriter::Write, image_writer_->AsWeakPtr()));
 }
 
-void ImageWriterHandler::OnVerifyStart(const base::FilePath& image,
-                                       const base::FilePath& device) {
+void ImageWriterHandler::Verify(
+    const base::FilePath& image,
+    const base::FilePath& device,
+    extensions::mojom::RemovableStorageWriterClientPtr client) {
+  client_ = std::move(client);
+  client_.set_connection_error_handler(
+      base::Bind(&ImageWriterHandler::Cancel, base::Unretained(this)));
+
+  base::FilePath target_device = device;
+  const bool test_mode = IsTestDevice(device);
+  if (test_mode)
+    target_device = MakeTestDevicePath(image);
+
+  // http://crbug.com/352442
   if (!image_writer_.get() || image != image_writer_->GetImagePath() ||
-      device != image_writer_->GetDevicePath()) {
-    image_writer_.reset(new ImageWriter(this, image, device));
+      target_device != image_writer_->GetDevicePath()) {
+    image_writer_.reset(new ImageWriter(this, image, target_device));
   }
 
   if (image_writer_->IsRunning()) {
     SendFailed(error::kOperationAlreadyInProgress);
     return;
   }
 
+  if (test_mode) {
+    image_writer_->Verify();
+    return;
+  }
+
   if (!image_writer_->IsValidDevice()) {
     SendFailed(error::kInvalidDevice);
     return;
   }
 
   image_writer_->Verify();
 }
 
-void ImageWriterHandler::OnCancel() {
-  if (image_writer_.get()) {
+void ImageWriterHandler::SendProgress(int64_t progress) {
+  client_->Progress(progress);
+}
+
+void ImageWriterHandler::SendSucceeded() {
+  client_->Complete(base::nullopt);
+  client_.reset();
+}
+
+void ImageWriterHandler::SendFailed(const std::string& error) {
+  client_->Complete(error);
+  client_.reset();
+}
+
+void ImageWriterHandler::Cancel() {
+  if (image_writer_.get())
     image_writer_->Cancel();
-  } else {
-    SendCancelled();
-  }
+  client_.reset();
 }
 
 }  // namespace image_writer