Revert of Convert utility process out-of-process file patching to mojo

chrome/browser/component_updater/component_patcher_operation_out_of_process.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/browser/component_updater/component_patcher_operation_out_of_process.h"
 
+#include <memory>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/files/file.h"
 #include "base/files/file_path.h"
-#include "base/sequenced_task_runner.h"
-#include "base/strings/string16.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "chrome/common/chrome_utility_messages.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/component_updater/component_updater_service.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/utility_process_host.h"
+#include "content/public/browser/utility_process_host_client.h"
+#include "courgette/courgette.h"
+#include "courgette/third_party/bsdiff/bsdiff.h"
+#include "ipc/ipc_message_macros.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace component_updater {
 
-ChromeOutOfProcessPatcher::ChromeOutOfProcessPatcher() = default;
+class PatchHost : public content::UtilityProcessHostClient {
+ public:
+  PatchHost(base::Callback<void(int result)> callback,
+            scoped_refptr<base::SequencedTaskRunner> task_runner);
 
-ChromeOutOfProcessPatcher::~ChromeOutOfProcessPatcher() = default;
+  void StartProcess(std::unique_ptr<IPC::Message> message);
+
+ private:
+  ~PatchHost() override;
+
+  void OnPatchFinished(int result);
+
+  // Overrides of content::UtilityProcessHostClient.
+  bool OnMessageReceived(const IPC::Message& message) override;
+
+  void OnProcessCrashed(int exit_code) override;
+
+  base::Callback<void(int result)> callback_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+};
+
+PatchHost::PatchHost(base::Callback<void(int result)> callback,
+                     scoped_refptr<base::SequencedTaskRunner> task_runner)
+    : callback_(callback), task_runner_(task_runner) {
+}
+
+PatchHost::~PatchHost() {
+}
+
+void PatchHost::StartProcess(std::unique_ptr<IPC::Message> message) {
+  // The DeltaUpdateOpPatchHost is not responsible for deleting the
+  // UtilityProcessHost object.
+  content::UtilityProcessHost* host = content::UtilityProcessHost::Create(
+      this, base::ThreadTaskRunnerHandle::Get().get());
+  host->SetName(l10n_util::GetStringUTF16(
+      IDS_UTILITY_PROCESS_COMPONENT_PATCHER_NAME));
+  host->Send(message.release());
+}
+
+bool PatchHost::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PatchHost, message)
+  IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_PatchFile_Finished, OnPatchFinished)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PatchHost::OnPatchFinished(int result) {
+  if (task_runner_.get()) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback_, result));
+    task_runner_ = NULL;
+  }
+}
+
+void PatchHost::OnProcessCrashed(int exit_code) {
+  if (task_runner_.get()) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback_, -1));
+    task_runner_ = NULL;
+  }
+}
+
+ChromeOutOfProcessPatcher::ChromeOutOfProcessPatcher() {
+}
+
+ChromeOutOfProcessPatcher::~ChromeOutOfProcessPatcher() {
+}
 
 void ChromeOutOfProcessPatcher::Patch(
     const std::string& operation,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const base::FilePath& input_abs_path,
     const base::FilePath& patch_abs_path,
     const base::FilePath& output_abs_path,
     base::Callback<void(int result)> callback) {
-  DCHECK(task_runner);
-  DCHECK(!input_abs_path.empty());
-  DCHECK(!patch_abs_path.empty());
-  DCHECK(!output_abs_path.empty());
-  DCHECK(!utility_process_mojo_client_);
-
-  task_runner_ = std::move(task_runner);
-  callback_ = callback;
-
-  base::File input_file(input_abs_path,
-                        base::File::FLAG_OPEN | base::File::FLAG_READ);
-  base::File patch_file(patch_abs_path,
-                        base::File::FLAG_OPEN | base::File::FLAG_READ);
-  base::File output_file(output_abs_path, base::File::FLAG_CREATE |
-                                              base::File::FLAG_WRITE |
-                                              base::File::FLAG_EXCLUSIVE_WRITE);
-
-  const base::string16 utility_process_name =
-      l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_COMPONENT_PATCHER_NAME);
-
-  utility_process_mojo_client_.reset(
-      new content::UtilityProcessMojoClient<chrome::mojom::FilePatcher>(
-          utility_process_name));
-  utility_process_mojo_client_->set_error_callback(
-      base::Bind(&ChromeOutOfProcessPatcher::PatchDone, this, -1));
-
-  utility_process_mojo_client_->Start();  // Start the utility process.
-
+  host_ = new PatchHost(callback, task_runner);
+  IPC::PlatformFileForTransit input = IPC::TakePlatformFileForTransit(
+      base::File(
+          input_abs_path, base::File::FLAG_OPEN | base::File::FLAG_READ));
+  IPC::PlatformFileForTransit patch = IPC::TakePlatformFileForTransit(
+      base::File(
+          patch_abs_path, base::File::FLAG_OPEN | base::File::FLAG_READ));
+  IPC::PlatformFileForTransit output = IPC::TakePlatformFileForTransit(
+      base::File(
+          output_abs_path,
+          base::File::FLAG_CREATE |
+              base::File::FLAG_WRITE |
+              base::File::FLAG_EXCLUSIVE_WRITE));
+  std::unique_ptr<IPC::Message> patch_message;
   if (operation == update_client::kBsdiff) {
-    utility_process_mojo_client_->service()->PatchFileBsdiff(
-        std::move(input_file), std::move(patch_file), std::move(output_file),
-        base::Bind(&ChromeOutOfProcessPatcher::PatchDone, this));
+    patch_message.reset(new ChromeUtilityMsg_PatchFileBsdiff(
+        input, patch, output));
   } else if (operation == update_client::kCourgette) {
-    utility_process_mojo_client_->service()->PatchFileCourgette(
-        std::move(input_file), std::move(patch_file), std::move(output_file),
-        base::Bind(&ChromeOutOfProcessPatcher::PatchDone, this));
+    patch_message.reset(new ChromeUtilityMsg_PatchFileCourgette(
+        input, patch, output));
   } else {
     NOTREACHED();
   }
-}
 
-void ChromeOutOfProcessPatcher::PatchDone(int result) {
-  utility_process_mojo_client_.reset();  // Terminate the utility process.
-  task_runner_->PostTask(FROM_HERE, base::Bind(callback_, result));
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &PatchHost::StartProcess, host_, base::Passed(&patch_message)));
 }
 
 }  // namespace component_updater