Use ChannelMojo in Pepper and NaCl processes.

content/browser/ppapi_plugin_process_host.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 "content/browser/ppapi_plugin_process_host.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/browser/browser_child_process_host_impl.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/content_switches_internal.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/sandbox_type.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "ipc/ipc_switches.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "net/base/network_change_notifier.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ui/base/ui_base_switches.h"
 
@@ skipping 17 matching lines @@
 
 // NOTE: changes to this class need to be reviewed by the security team.
 class PpapiPluginSandboxedProcessLauncherDelegate
     : public content::SandboxedProcessLauncherDelegate {
  public:
   PpapiPluginSandboxedProcessLauncherDelegate(bool is_broker,
                                               const PepperPluginInfo& info,
                                               ChildProcessHost* host)
 #if defined(OS_WIN)
       : info_(info), is_broker_(is_broker) {
-#elif defined(OS_MACOSX) || defined(OS_ANDROID)
-      : ipc_fd_(host->TakeClientFileDescriptor()) {
-#elif defined(OS_POSIX)
-      : ipc_fd_(host->TakeClientFileDescriptor()), is_broker_(is_broker) {
+#elif defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
+      : is_broker_(is_broker) {
 #else
   {
 #endif
   }
 
   ~PpapiPluginSandboxedProcessLauncherDelegate() override {}
 
 #if defined(OS_WIN)
   bool ShouldSandbox() override {
     return !is_broker_;
@@ skipping 42 matching lines @@
     const base::CommandLine& browser_command_line =
         *base::CommandLine::ForCurrentProcess();
     base::CommandLine::StringType plugin_launcher = browser_command_line
         .GetSwitchValueNative(switches::kPpapiPluginLauncher);
     if (is_broker_ || !plugin_launcher.empty())
       return nullptr;
     return GetGenericZygote();
   }
 #endif  // !defined(OS_MACOSX) && !defined(OS_ANDROID)
 
-  base::ScopedFD TakeIpcFd() override { return std::move(ipc_fd_); }
+  base::ScopedFD TakeIpcFd() override { return base::ScopedFD(-1); }
 #endif  // OS_WIN
 
   SandboxType GetSandboxType() override {
     return SANDBOX_TYPE_PPAPI;
   }
 
  private:
 #if defined(OS_WIN)
   const PepperPluginInfo& info_;
 #endif // OS_WIN
-#if defined(OS_POSIX)
-  base::ScopedFD ipc_fd_;
-#endif  // OS_POSIX
 #if (defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)) || \
     defined(OS_WIN)
   bool is_broker_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(PpapiPluginSandboxedProcessLauncherDelegate);
 };
 
 class PpapiPluginProcessHost::PluginNetworkObserver
     : public net::NetworkChangeNotifier::IPAddressObserver,
@@ skipping 154 matching lines @@
   }
 
   // We already have an open channel, send a request right away to plugin.
   RequestPluginChannel(client);
 }
 
 PpapiPluginProcessHost::PpapiPluginProcessHost(
     const PepperPluginInfo& info,
     const base::FilePath& profile_data_directory)
     : profile_data_directory_(profile_data_directory),
-      is_broker_(false) {
+      is_broker_(false),
+      mojo_child_token_(mojo::edk::GenerateRandomToken()) {
   uint32_t base_permissions = info.permissions;
 
   // We don't have to do any whitelisting for APIs in this process host, so
   // don't bother passing a browser context or document url here.
   if (GetContentClient()->browser()->IsPluginAllowedToUseDevChannelAPIs(
           NULL, GURL()))
     base_permissions |= ppapi::PERMISSION_DEV_CHANNEL;
   permissions_ = ppapi::PpapiPermissions::GetForCommandLine(base_permissions);
 
   process_.reset(new BrowserChildProcessHostImpl(
-      PROCESS_TYPE_PPAPI_PLUGIN, this, mojo::edk::GenerateRandomToken()));
+      PROCESS_TYPE_PPAPI_PLUGIN, this, mojo_child_token_));
 
   host_impl_.reset(new BrowserPpapiHostImpl(this, permissions_, info.name,
                                             info.path, profile_data_directory,
                                             false /* in_process */,
                                             false /* external_plugin */));
 
   filter_ = new PepperMessageFilter();
   process_->AddFilter(filter_.get());
   process_->GetHost()->AddFilter(host_impl_->message_filter().get());
 #if defined(OS_WIN)
   process_->AddFilter(new DWriteFontProxyMessageFilter());
 #endif
 
   GetContentClient()->browser()->DidCreatePpapiPlugin(host_impl_.get());
 
   // Only request network status updates if the plugin has dev permissions.
   if (permissions_.HasPermission(ppapi::PERMISSION_DEV))
     network_observer_.reset(new PluginNetworkObserver(this));
 }
 
 PpapiPluginProcessHost::PpapiPluginProcessHost()
-    : is_broker_(true) {
+    : is_broker_(true), mojo_child_token_(mojo::edk::GenerateRandomToken()) {
   process_.reset(new BrowserChildProcessHostImpl(
-      PROCESS_TYPE_PPAPI_BROKER, this, mojo::edk::GenerateRandomToken()));
+      PROCESS_TYPE_PPAPI_BROKER, this, mojo_child_token_));
 
   ppapi::PpapiPermissions permissions;  // No permissions.
   // The plugin name, path and profile data directory shouldn't be needed for
   // the broker.
   host_impl_.reset(new BrowserPpapiHostImpl(this, permissions,
                                             std::string(), base::FilePath(),
                                             base::FilePath(),
                                             false /* in_process */,
                                             false /* external_plugin */));
 }
 
 bool PpapiPluginProcessHost::Init(const PepperPluginInfo& info) {
   plugin_path_ = info.path;
   if (info.name.empty()) {
     process_->SetName(plugin_path_.BaseName().LossyDisplayName());
   } else {
     process_->SetName(base::UTF8ToUTF16(info.name));
   }
 
-  std::string channel_id = process_->GetHost()->CreateChannel();
-  if (channel_id.empty()) {
+  std::string mojo_channel_token =
+      process_->GetHost()->CreateChannelMojo(mojo_child_token_);
+  if (mojo_channel_token.empty()) {
     VLOG(1) << "Could not create pepper host channel.";
     return false;
   }
 
   const base::CommandLine& browser_command_line =
       *base::CommandLine::ForCurrentProcess();
   base::CommandLine::StringType plugin_launcher =
       browser_command_line.GetSwitchValueNative(switches::kPpapiPluginLauncher);
 
 #if defined(OS_LINUX)
   int flags = plugin_launcher.empty() ? ChildProcessHost::CHILD_ALLOW_SELF :
                                         ChildProcessHost::CHILD_NORMAL;
 #else
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
   base::FilePath exe_path = ChildProcessHost::GetChildPath(flags);
   if (exe_path.empty()) {
     VLOG(1) << "Pepper plugin exe path is empty.";
     return false;
   }
 
   base::CommandLine* cmd_line = new base::CommandLine(exe_path);
   cmd_line->AppendSwitchASCII(switches::kProcessType,
                               is_broker_ ? switches::kPpapiBrokerProcess
                                          : switches::kPpapiPluginProcess);
-  cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
+  cmd_line->AppendSwitchASCII(switches::kMojoChannelToken, mojo_channel_token);
 
 #if defined(OS_WIN)
   if (GetContentClient()->browser()->ShouldUseWindowsPrefetchArgument()) {
     cmd_line->AppendArg(is_broker_ ? switches::kPrefetchArgumentPpapiBroker
                                    : switches::kPrefetchArgumentPpapi);
   }
 #endif  // defined(OS_WIN)
 
   // These switches are forwarded to both plugin and broker pocesses.
   static const char* const kCommonForwardSwitches[] = {
@@ skipping 141 matching lines @@
   // sent_requests_ queue should be the one that the plugin just created.
   Client* client = sent_requests_.front();
   sent_requests_.pop();
 
   const ChildProcessData& data = process_->GetData();
   client->OnPpapiChannelOpened(channel_handle, base::GetProcId(data.handle),
                                data.id);
 }
 
 }  // namespace content