Use ChannelMojo between browser and service processes.

chrome/service/service_process.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/service/service_process.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/base_switches.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
@@ skipping 13 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/service_process_util.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/service/cloud_print/cloud_print_message_handler.h"
 #include "chrome/service/cloud_print/cloud_print_proxy.h"
 #include "chrome/service/net/service_url_request_context_getter.h"
 #include "chrome/service/service_process_prefs.h"
 #include "components/prefs/json_pref_store.h"
 #include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/named_platform_handle.h"
+#include "mojo/edk/embedder/named_platform_handle_utils.h"
+#include "mojo/edk/embedder/platform_handle_utils.h"
 #include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "net/base/network_change_notifier.h"
 #include "net/url_request/url_fetcher.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(USE_GLIB)
 #include <glib-object.h>
@@ skipping 60 matching lines @@
       l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT)));
   base::i18n::AdjustStringForLocaleDirection(&adjusted_string);
   dlg_strings.append(adjusted_string);
   dlg_strings.push_back('|');
   dlg_strings.append(base::ASCIIToUTF16(
       base::i18n::IsRTL() ? env_vars::kRtlLocale : env_vars::kLtrLocale));
 
   env->SetVar(env_vars::kRestartInfo, base::UTF16ToUTF8(dlg_strings));
 }
 
+#if defined(OS_POSIX)
+mojo::edk::ScopedPlatformHandle CreateServerHandle(
+    const IPC::ChannelHandle& channel_handle) {
+#if defined(OS_MACOSX)
+  mojo::edk::PlatformHandle platform_handle(channel_handle.socket.fd);
+  platform_handle.needs_connection = true;
+  return mojo::edk::ScopedPlatformHandle(platform_handle);
+#else
+  return mojo::edk::CreateServerHandle(
+      mojo::edk::NamedPlatformHandle(channel_handle.name), false);
+#endif
+}
+#endif
+
 }  // namespace
 
 ServiceProcess::ServiceProcess()
     : shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL,
                       base::WaitableEvent::InitialState::NOT_SIGNALED),
       main_message_loop_(NULL),
       enabled_services_(0),
       update_available_(false) {
   DCHECK(!g_service_process);
   g_service_process = this;
@@ skipping 67 matching lines @@
   PrepareRestartOnCrashEnviroment(command_line);
 
   // Enable Cloud Print if needed. First check the command-line.
   // Then check if the cloud print proxy was previously enabled.
   if (command_line.HasSwitch(switches::kEnableCloudPrintProxy) ||
       service_prefs_->GetBoolean(prefs::kCloudPrintProxyEnabled, false)) {
     GetCloudPrintProxy()->EnableForUser();
   }
 
   VLOG(1) << "Starting Service Process IPC Server";
-  ipc_server_.reset(new ServiceIPCServer(
-      this /* client */,
-      io_task_runner(),
-      service_process_state_->GetServiceProcessChannel(),
-      &shutdown_event_));
+
+  ipc_server_.reset(new ServiceIPCServer(this /* client */, io_task_runner(),
+                                         &shutdown_event_));
   ipc_server_->AddMessageHandler(base::WrapUnique(
       new cloud_print::CloudPrintMessageHandler(ipc_server_.get(), this)));
   ipc_server_->Init();
 
   // After the IPC server has started we signal that the service process is
   // ready.
   if (!service_process_state_->SignalReady(
           io_task_runner().get(),
           base::Bind(&ServiceProcess::Terminate, base::Unretained(this)))) {
     return false;
@@ skipping 60 matching lines @@
 }
 
 void ServiceProcess::OnShutdown() {
   Shutdown();
 }
 
 void ServiceProcess::OnUpdateAvailable() {
   update_available_ = true;
 }
 
+void ServiceProcess::OnStayAliveForTesting() {
+  enabled_services_++;
+}
+
 bool ServiceProcess::OnIPCClientDisconnect() {
   // If there are no enabled services or if there is an update available
   // we want to shutdown right away. Else we want to keep listening for
   // new connections.
   if (!enabled_services_ || update_available_) {
     Shutdown();
     return false;
   }
   return true;
 }
 
+mojo::ScopedMessagePipeHandle ServiceProcess::CreateChannelMessagePipe() {
+  if (!server_handle_.is_valid()) {
+#if defined(OS_POSIX)
+    server_handle_ =
+        CreateServerHandle(service_process_state_->GetServiceProcessChannel());
+#elif defined(OS_WIN)
+    server_handle_ = mojo::edk::NamedPlatformHandle(
+        service_process_state_->GetServiceProcessChannel().name);
+#endif
+    DCHECK(server_handle_.is_valid());
+  }
+
+  mojo::edk::ScopedPlatformHandle channel_handle;
+#if defined(OS_POSIX)
+  channel_handle = mojo::edk::DuplicatePlatformHandle(server_handle_.get());
+#elif defined(OS_WIN)
+  channel_handle = mojo::edk::CreateServerHandle(server_handle_, false);
+#endif
+  CHECK(channel_handle.is_valid());
+
+  return mojo::edk::ConnectToPeerProcess(std::move(channel_handle));
+}
+
 cloud_print::CloudPrintProxy* ServiceProcess::GetCloudPrintProxy() {
   if (!cloud_print_proxy_.get()) {
     cloud_print_proxy_.reset(new cloud_print::CloudPrintProxy());
     cloud_print_proxy_->Initialize(service_prefs_.get(), this);
   }
   return cloud_print_proxy_.get();
 }
 
 void ServiceProcess::OnCloudPrintProxyEnabled(bool persist_state) {
   if (persist_state) {
@@ skipping 62 matching lines @@
     } else {
       Shutdown();
     }
   }
 }
 
 ServiceProcess::~ServiceProcess() {
   Teardown();
   g_service_process = NULL;
 }