Convert utility process zip creator IPC to mojo

chrome/browser/chromeos/file_manager/zip_file_creator.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 "chrome/browser/chromeos/file_manager/zip_file_creator.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
-#include "base/message_loop/message_loop.h"
 #include "base/task_scheduler/post_task.h"
-#include "chrome/common/chrome_utility_messages.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/utility_process_host.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using content::BrowserThread;
-using content::UtilityProcessHost;
-
 namespace {
 
 // Creates the destination zip file only if it does not already exist.
 base::File OpenFileHandleAsync(const base::FilePath& zip_path) {
   return base::File(zip_path, base::File::FLAG_CREATE | base::File::FLAG_WRITE);
 }
 
 }  // namespace
 
 namespace file_manager {
 
 ZipFileCreator::ZipFileCreator(
     const ResultCallback& callback,
     const base::FilePath& src_dir,
     const std::vector<base::FilePath>& src_relative_paths,
     const base::FilePath& dest_file)
     : callback_(callback),
       src_dir_(src_dir),
       src_relative_paths_(src_relative_paths),
       dest_file_(dest_file) {
   DCHECK(!callback_.is_null());
 }
 
 void ZipFileCreator::Start() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, base::TaskTraits().MayBlock(),
       base::Bind(&OpenFileHandleAsync, dest_file_),
-      base::Bind(&ZipFileCreator::OnOpenFileHandle, this));
+      base::Bind(&ZipFileCreator::CreateZipFile, this));
 }
 
-ZipFileCreator::~ZipFileCreator() {
-}
+ZipFileCreator::~ZipFileCreator() = default;
 
-bool ZipFileCreator::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ZipFileCreator, message)
-    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_CreateZipFile_Succeeded,
-                        OnCreateZipFileSucceeded)
-    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_CreateZipFile_Failed,
-                        OnCreateZipFileFailed)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void ZipFileCreator::OnProcessCrashed(int exit_code) {
-  ReportDone(false);
-}
-
-void ZipFileCreator::OnOpenFileHandle(base::File file) {
+void ZipFileCreator::CreateZipFile(base::File file) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(!utility_process_mojo_client_);
 
   if (!file.IsValid()) {
     LOG(ERROR) << "Failed to create dest zip file " << dest_file_.value();
     ReportDone(false);
     return;
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(
-          &ZipFileCreator::StartProcessOnIOThread, this, base::Passed(&file)));
-}
+  utility_process_mojo_client_ = base::MakeUnique<
+      content::UtilityProcessMojoClient<chrome::mojom::ZipFileCreator>>(
+      l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_ZIP_FILE_CREATOR_NAME));
+  utility_process_mojo_client_->set_error_callback(
+      base::Bind(&ZipFileCreator::ReportDone, this, false));
 
-void ZipFileCreator::StartProcessOnIOThread(base::File dest_file) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  utility_process_mojo_client_->set_exposed_directory(src_dir_);
 
-  base::FileDescriptor dest_fd(std::move(dest_file));
+  utility_process_mojo_client_->Start();
 
-  UtilityProcessHost* host = UtilityProcessHost::Create(
-      this, BrowserThread::GetTaskRunnerForThread(BrowserThread::UI).get());
-  host->SetName(
-      l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_ZIP_FILE_CREATOR_NAME));
-  host->SetExposedDir(src_dir_);
-  host->Send(new ChromeUtilityMsg_CreateZipFile(src_dir_, src_relative_paths_,
-                                                dest_fd));
-}
-
-void ZipFileCreator::OnCreateZipFileSucceeded() {
-  ReportDone(true);
-}
-
-void ZipFileCreator::OnCreateZipFileFailed() {
-  ReportDone(false);
+  utility_process_mojo_client_->service()->CreateZipFile(
+      src_dir_, src_relative_paths_, std::move(file),
+      base::Bind(&ZipFileCreator::ReportDone, this));
 }
 
 void ZipFileCreator::ReportDone(bool success) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  // Guard against calling observer multiple times.
-  if (!callback_.is_null())
-    base::ResetAndReturn(&callback_).Run(success);
+  // The current user of this class holds no reference to |this| so resetting
+  // the |utility_process_mojo_client_| here could release the last reference
+  // and delete |this|. So save |callback_| before resetting the client.

[Noel Gordon, 2017/03/01 03:22:47]

sammc, tibell: I figure that mojo users might need to add a similar comment in
their code, because of the way ref counted types and base::Bind work behind the
scenes, which (to me) sometimes makes it hard to reason about ref counts.

Was thinking that if mojo always used the pattern here (save the callback first,
before invoking it), then an extra ref on the callback's |this| client (for
refcounted |this|) would be assured.   So any clients that delete / reset their
mojo stuff during the mojo callback, as in this code, would not need the comment
... since |this| would be guaranteed to have at least one ref for the duration
of the mojo callback.

Something to think about, anyho ...

+  auto callback = base::ResetAndReturn(&callback_);
+  utility_process_mojo_client_.reset();
+  callback.Run(success);
 }
 
 }  // namespace file_manager