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

chrome/utility/chrome_content_utility_client.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/utility/chrome_content_utility_client.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_utility_messages.h"
+#include "chrome/common/file_patcher.mojom.h"
 #include "chrome/common/safe_browsing/zip_analyzer.h"
 #include "chrome/common/safe_browsing/zip_analyzer_results.h"
 #include "chrome/utility/chrome_content_utility_ipc_whitelist.h"
 #include "chrome/utility/utility_message_handler.h"
 #include "components/safe_json/utility/safe_json_parser_mojo_impl.h"
 #include "content/public/child/image_decoder_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/service_info.h"
 #include "content/public/utility/utility_thread.h"
 #include "courgette/courgette.h"
@@ skipping 30 matching lines @@
     (BUILDFLAG(ENABLE_BASIC_PRINTING) && defined(OS_WIN))
 #include "chrome/utility/printing_handler.h"
 #endif
 
 #if defined(OS_MACOSX) && defined(FULL_SAFE_BROWSING)
 #include "chrome/utility/safe_browsing/mac/dmg_analyzer.h"
 #endif
 
 namespace {
 
+#if defined(OS_CHROMEOS) || defined(FULL_SAFE_BROWSING)
 bool Send(IPC::Message* message) {
   return content::UtilityThread::Get()->Send(message);
 }
 
 void ReleaseProcessIfNeeded() {
   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
 }
+#endif  // defined(OS_CHROMEOS) || defined(FULL_SAFE_BROWSING)
+
+class FilePatcherImpl : public chrome::mojom::FilePatcher {
+ public:
+  FilePatcherImpl() = default;
+  ~FilePatcherImpl() override = default;
+
+  static void Create(chrome::mojom::FilePatcherRequest request) {
+    mojo::MakeStrongBinding(base::MakeUnique<FilePatcherImpl>(),
+                            std::move(request));
+  }
+
+ private:
+  // chrome::mojom::FilePatcher:
+
+  void PatchFileBsdiff(base::File input_file,
+                       base::File patch_file,
+                       base::File output_file,
+                       const PatchFileBsdiffCallback& callback) override {
+    const int patch_result_status = bsdiff::ApplyBinaryPatch(
+        std::move(input_file), std::move(patch_file), std::move(output_file));
+    callback.Run(patch_result_status);
+  }
+
+  void PatchFileCourgette(base::File input_file,
+                          base::File patch_file,
+                          base::File output_file,
+                          const PatchFileCourgetteCallback& callback) override {
+    const int patch_result_status = courgette::ApplyEnsemblePatch(
+        std::move(input_file), std::move(patch_file), std::move(output_file));
+    callback.Run(patch_result_status);
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(FilePatcherImpl);
+};
 
 #if !defined(OS_ANDROID)
 void CreateProxyResolverFactory(
     net::interfaces::ProxyResolverFactoryRequest request) {
   mojo::MakeStrongBinding(base::MakeUnique<net::MojoProxyResolverFactoryImpl>(),
                           std::move(request));
 }
 
 class ResourceUsageReporterImpl : public chrome::mojom::ResourceUsageReporter {
  public:
@@ skipping 65 matching lines @@
 
 bool ChromeContentUtilityClient::OnMessageReceived(
     const IPC::Message& message) {
   if (filter_messages_ &&
       !base::ContainsKey(message_id_whitelist_, message.type())) {
     return false;
   }
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeContentUtilityClient, message)
-    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_PatchFileBsdiff,
-                        OnPatchFileBsdiff)
-    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_PatchFileCourgette,
-                        OnPatchFileCourgette)
 #if defined(FULL_SAFE_BROWSING)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_AnalyzeZipFileForDownloadProtection,
                         OnAnalyzeZipFileForDownloadProtection)
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_AnalyzeDmgFileForDownloadProtection,
                         OnAnalyzeDmgFileForDownloadProtection)
 #endif  // defined(OS_MACOSX)
 #endif  // defined(FULL_SAFE_BROWSING)
 #if defined(OS_CHROMEOS)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_CreateZipFile, OnCreateZipFile)
@@ skipping 21 matching lines @@
     service_manager::InterfaceRegistry* registry) {
   // When the utility process is running with elevated privileges, we need to
   // filter messages so that only a whitelist of IPCs can run. In Mojo, there's
   // no way of filtering individual messages. Instead, we can avoid adding
   // non-whitelisted Mojo services to the service_manager::InterfaceRegistry.
   // TODO(amistry): Use a whitelist once the whistlisted IPCs have been
   // converted to Mojo.
   if (filter_messages_)
     return;
 
+  registry->AddInterface(base::Bind(&FilePatcherImpl::Create));
 #if !defined(OS_ANDROID)
   registry->AddInterface<net::interfaces::ProxyResolverFactory>(
       base::Bind(CreateProxyResolverFactory));
   registry->AddInterface(base::Bind(CreateResourceUsageReporter));
   registry->AddInterface(base::Bind(&ProfileImportHandler::Create));
 #endif
   registry->AddInterface(
       base::Bind(&safe_json::SafeJsonParserMojoImpl::Create));
 #if defined(OS_WIN)
   registry->AddInterface(base::Bind(&ShellHandlerImpl::Create));
@@ skipping 44 matching lines @@
     succeeded = zip::ZipFiles(src_dir, src_relative_paths, dest_fd.fd);
 
   if (succeeded)
     Send(new ChromeUtilityHostMsg_CreateZipFile_Succeeded());
   else
     Send(new ChromeUtilityHostMsg_CreateZipFile_Failed());
   ReleaseProcessIfNeeded();
 }
 #endif  // defined(OS_CHROMEOS)
 
-void ChromeContentUtilityClient::OnPatchFileBsdiff(
-    const IPC::PlatformFileForTransit& input_file,
-    const IPC::PlatformFileForTransit& patch_file,
-    const IPC::PlatformFileForTransit& output_file) {
-  const int patch_status = bsdiff::ApplyBinaryPatch(
-      IPC::PlatformFileForTransitToFile(input_file),
-      IPC::PlatformFileForTransitToFile(patch_file),
-      IPC::PlatformFileForTransitToFile(output_file));
-  Send(new ChromeUtilityHostMsg_PatchFile_Finished(patch_status));
-  ReleaseProcessIfNeeded();
-}
-
-void ChromeContentUtilityClient::OnPatchFileCourgette(
-    const IPC::PlatformFileForTransit& input_file,
-    const IPC::PlatformFileForTransit& patch_file,
-    const IPC::PlatformFileForTransit& output_file) {
-  const int patch_status = courgette::ApplyEnsemblePatch(
-      IPC::PlatformFileForTransitToFile(input_file),
-      IPC::PlatformFileForTransitToFile(patch_file),
-      IPC::PlatformFileForTransitToFile(output_file));
-  Send(new ChromeUtilityHostMsg_PatchFile_Finished(patch_status));
-  ReleaseProcessIfNeeded();
-}
-
 #if defined(FULL_SAFE_BROWSING)
 void ChromeContentUtilityClient::OnAnalyzeZipFileForDownloadProtection(
     const IPC::PlatformFileForTransit& zip_file,
     const IPC::PlatformFileForTransit& temp_file) {
   safe_browsing::zip_analyzer::Results results;
   safe_browsing::zip_analyzer::AnalyzeZipFile(
       IPC::PlatformFileForTransitToFile(zip_file),
       IPC::PlatformFileForTransitToFile(temp_file), &results);
   Send(new ChromeUtilityHostMsg_AnalyzeZipFileForDownloadProtection_Finished(
       results));
   ReleaseProcessIfNeeded();
 }
 
 #if defined(OS_MACOSX)
 void ChromeContentUtilityClient::OnAnalyzeDmgFileForDownloadProtection(
     const IPC::PlatformFileForTransit& dmg_file) {
   safe_browsing::zip_analyzer::Results results;
   safe_browsing::dmg::AnalyzeDMGFile(
       IPC::PlatformFileForTransitToFile(dmg_file), &results);
   Send(new ChromeUtilityHostMsg_AnalyzeDmgFileForDownloadProtection_Finished(
       results));
   ReleaseProcessIfNeeded();
 }
 #endif  // defined(OS_MACOSX)
 
 #endif  // defined(FULL_SAFE_BROWSING)