Use an explicit PID for duplicating Pepper handles rather than the Channel's.

content/ppapi_plugin/ppapi_thread.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/ppapi_plugin/ppapi_thread.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 149 matching lines @@
 base::MessageLoopProxy* PpapiThread::GetIPCMessageLoop() {
   return ChildProcess::current()->io_message_loop_proxy();
 }
 
 base::WaitableEvent* PpapiThread::GetShutdownEvent() {
   return ChildProcess::current()->GetShutDownEvent();
 }
 
 IPC::PlatformFileForTransit PpapiThread::ShareHandleWithRemote(
     base::PlatformFile handle,
-    const IPC::SyncChannel& channel,
+    base::ProcessId peer_pid,
     bool should_close_source) {
 #if defined(OS_WIN)
   if (peer_handle_.IsValid()) {
     DCHECK(is_broker_);
     return IPC::GetFileHandleForProcess(handle, peer_handle_,
                                         should_close_source);
   }
 #endif
 
-  return BrokerGetFileHandleForProcess(handle, channel.peer_pid(),
-                                       should_close_source);
+  DCHECK(peer_pid != base::kNullProcessId);
+  return BrokerGetFileHandleForProcess(handle, peer_pid, should_close_source);
 }
 
 std::set<PP_Instance>* PpapiThread::GetGloballySeenInstanceIDSet() {
   return &globally_seen_instance_ids_;
 }
 
 IPC::Sender* PpapiThread::GetBrowserSender() {
   return this;
 }
 
@@ skipping 154 matching lines @@
     if (init_error != PP_OK) {
       LOG(WARNING) << "InitModule failed with error " << init_error;
       return;
     }
   }
 
   // Initialization succeeded, so keep the plugin DLL loaded.
   library_.Reset(library.Release());
 }
 
-void PpapiThread::OnCreateChannel(int renderer_id, bool incognito) {
+void PpapiThread::OnCreateChannel(base::ProcessId renderer_pid,
+                                  int renderer_child_id,
+                                  bool incognito) {
   IPC::ChannelHandle channel_handle;
 
   if (!plugin_entry_points_.get_interface ||  // Plugin couldn't be loaded.
-      !SetupRendererChannel(renderer_id, incognito, &channel_handle)) {
+      !SetupRendererChannel(renderer_pid, renderer_child_id, incognito,
+                            &channel_handle)) {
     Send(new PpapiHostMsg_ChannelCreated(IPC::ChannelHandle()));
     return;
   }
 
   Send(new PpapiHostMsg_ChannelCreated(channel_handle));
 }
 
 void PpapiThread::OnResourceReply(
     const ppapi::proxy::ResourceMessageReplyParams& reply_params,
     const IPC::Message& nested_msg) {
   ppapi::proxy::PluginDispatcher::DispatchResourceReply(reply_params,
                                                         nested_msg);
 }
 
 void PpapiThread::OnSetNetworkState(bool online) {
   // Note the browser-process side shouldn't send us these messages in the
   // first unless the plugin has dev permissions, so we don't need to check
   // again here. We don't want random plugins depending on this dev interface.
   if (!plugin_entry_points_.get_interface)
     return;
   const PPP_NetworkState_Dev* ns = static_cast<const PPP_NetworkState_Dev*>(
       plugin_entry_points_.get_interface(PPP_NETWORK_STATE_DEV_INTERFACE));
   if (ns)
     ns->SetOnLine(PP_FromBool(online));
 }
 
-bool PpapiThread::SetupRendererChannel(int renderer_id,
+bool PpapiThread::SetupRendererChannel(base::ProcessId renderer_pid,
+                                       int renderer_child_id,
                                        bool incognito,
                                        IPC::ChannelHandle* handle) {
   DCHECK(is_broker_ == (connect_instance_func_ != NULL));
   IPC::ChannelHandle plugin_handle;
   plugin_handle.name = IPC::Channel::GenerateVerifiedChannelID(
-      StringPrintf("%d.r%d", base::GetCurrentProcId(), renderer_id));
+      StringPrintf("%d.r%d", base::GetCurrentProcId(), renderer_child_id));
 
   ppapi::proxy::ProxyChannel* dispatcher = NULL;
   bool init_result = false;
   if (is_broker_) {
     BrokerProcessDispatcher* broker_dispatcher =
         new BrokerProcessDispatcher(plugin_entry_points_.get_interface,
                                     connect_instance_func_);
     init_result = broker_dispatcher->InitBrokerWithChannel(this,
+                                                           renderer_pid,
                                                            plugin_handle,
                                                            false);
     dispatcher = broker_dispatcher;
   } else {
     PluginProcessDispatcher* plugin_dispatcher =
         new PluginProcessDispatcher(plugin_entry_points_.get_interface,
                                     permissions_,
                                     incognito);
     init_result = plugin_dispatcher->InitPluginWithChannel(this,
+                                                           renderer_pid,
                                                            plugin_handle,
                                                            false);
     dispatcher = plugin_dispatcher;
   }
 
   if (!init_result) {
     delete dispatcher;
     return false;
   }
 
@@ skipping 18 matching lines @@
 
   // plugin() is NULL when in-process.  Which is fine, because this is
   // just a hook for setting the process name.
   if (GetContentClient()->plugin()) {
     GetContentClient()->plugin()->PluginProcessStarted(
         path.BaseName().RemoveExtension().LossyDisplayName());
   }
 }
 
 }  // namespace content