Convert utility process ImageWriter IPC 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/ptr_util.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"
 #include "courgette/third_party/bsdiff/bsdiff.h"
 #include "extensions/features/features.h"
 #include "ipc/ipc_channel.h"
@@ skipping 13 matching lines @@
 #include "net/proxy/proxy_resolver_v8.h"
 #endif
 
 #if defined(OS_WIN)
 #include "chrome/utility/ipc_shell_handler_win.h"
 #include "chrome/utility/shell_handler_impl_win.h"
 #endif
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "chrome/utility/extensions/extensions_handler.h"
-#include "chrome/utility/image_writer/image_writer_handler.h"
 #endif
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW) || \
     (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
@@ skipping 77 matching lines @@
 #endif  // !defined(OS_ANDROID)
 
 std::unique_ptr<service_manager::Service> CreateImageDecoderService() {
   content::UtilityThread::Get()->EnsureBlinkInitialized();
   return image_decoder::ImageDecoderService::Create();
 }
 
 }  // namespace
 
 ChromeContentUtilityClient::ChromeContentUtilityClient()
-    : filter_messages_(false) {
+    : utility_process_running_elevated_(false) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   handlers_.push_back(new extensions::ExtensionsHandler());
-  handlers_.push_back(new image_writer::ImageWriterHandler());
 #endif
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW) || \
     (BUILDFLAG(ENABLE_BASIC_PRINTING) && defined(OS_WIN))
   handlers_.push_back(new printing::PrintingHandler());
 #endif
 
 #if defined(OS_WIN)
   handlers_.push_back(new IPCShellHandler());
 #endif
 }
 
-ChromeContentUtilityClient::~ChromeContentUtilityClient() {
-}
+ChromeContentUtilityClient::~ChromeContentUtilityClient() = default;
 
 void ChromeContentUtilityClient::UtilityThreadStarted() {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   extensions::UtilityHandler::UtilityThreadStarted();
 #endif
 
-  if (kMessageWhitelistSize > 0) {
-    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-    if (command_line->HasSwitch(switches::kUtilityProcessRunningElevated)) {
-      message_id_whitelist_.insert(kMessageWhitelist,
-                                   kMessageWhitelist + kMessageWhitelistSize);
-      filter_messages_ = true;
-    }
-  }
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kUtilityProcessRunningElevated))
+    utility_process_running_elevated_ = true;
 }
 
 bool ChromeContentUtilityClient::OnMessageReceived(
     const IPC::Message& message) {
-  if (filter_messages_ &&
-      !base::ContainsKey(message_id_whitelist_, message.type())) {
+  if (utility_process_running_elevated_)
     return false;
-  }
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeContentUtilityClient, message)
 #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)
@@ skipping 15 matching lines @@
     // for loop was using iterators explicitly, as originally done).
     if (handler->OnMessageReceived(message))
       return true;
   }
 
   return false;
 }
 
 void ChromeContentUtilityClient::ExposeInterfacesToBrowser(
     service_manager::InterfaceRegistry* registry) {
-  const bool running_elevated =
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUtilityProcessRunningElevated);
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   ChromeContentUtilityClient* utility_client = this;
   extensions::ExtensionsHandler::ExposeInterfacesToBrowser(
-      registry, utility_client, running_elevated);
+      registry, utility_client, utility_process_running_elevated_);
 #endif
   // If our process runs with elevated privileges, only add elevated Mojo
   // services to the interface registry.
-  if (running_elevated)
+  if (utility_process_running_elevated_)
     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(
@@ skipping 73 matching lines @@
   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)