Broker out PPAPI handle duplication

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/process_util.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "content/common/child_process.h"
 #include "content/common/child_process_messages.h"
 #include "content/ppapi_plugin/broker_process_dispatcher.h"
 #include "content/ppapi_plugin/plugin_process_dispatcher.h"
 #include "content/ppapi_plugin/ppapi_webkitplatformsupport_impl.h"
 #include "content/public/common/sandbox_init.h"
 #include "ipc/ipc_channel_handle.h"
+#include "ipc/ipc_platform_file.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ppapi/c/dev/ppp_network_state_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppp.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/interface_list.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "webkit/plugins/plugin_switches.h"
 
@@ skipping 11 matching lines @@
 
 typedef int32_t (*InitializeBrokerFunc)
     (PP_ConnectInstance_Func* connect_instance_func);
 
 PpapiThread::PpapiThread(const CommandLine& command_line, bool is_broker)
     : is_broker_(is_broker),
       get_plugin_interface_(NULL),
       connect_instance_func_(NULL),
       local_pp_module_(
           base::RandInt(0, std::numeric_limits<PP_Module>::max())),
-      next_plugin_dispatcher_id_(1) {
+      next_plugin_dispatcher_id_(1),
+      peer_handle_(base::kNullProcessHandle) {
   ppapi::proxy::PluginGlobals* globals = ppapi::proxy::PluginGlobals::Get();
   globals->set_plugin_proxy_delegate(this);
   globals->set_command_line(
       command_line.GetSwitchValueASCII(switches::kPpapiFlashArgs));
 
   webkit_platform_support_.reset(new PpapiWebKitPlatformSupportImpl);
   WebKit::initialize(webkit_platform_support_.get());
 }
 
 PpapiThread::~PpapiThread() {
@@ skipping 47 matching lines @@
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBTalk_GetPermissionACK,
                                 OnPluginDispatcherMessageReceived(msg))
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBHostResolver_ResolveACK,
                                 OnPluginDispatcherMessageReceived(msg))
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBNetworkMonitor_NetworkList,
                                 OnPluginDispatcherMessageReceived(msg))
     IPC_MESSAGE_HANDLER(PpapiMsg_SetNetworkState, OnMsgSetNetworkState)
   IPC_END_MESSAGE_MAP()
   return true;
 }
+void PpapiThread::OnChannelConnected(int32 peer_pid) {

[jschuh, 2012/05/10 00:10:57]

We cache a handle to the other end here, because it's a broker process.

+#if defined(OS_WIN)
+  if (is_broker_)
+    peer_handle_ = ::OpenProcess(PROCESS_DUP_HANDLE, FALSE, peer_pid);

[cpu_(ooo_6.6-7.5), 2012/05/10 22:10:43]

do we ever close the peer handle? base::ProcessHandle is just a typedef right?

[jschuh, 2012/05/10 22:16:28]

D'oh. I thought I'd made that a scoped handle. Fixing it now.

+#endif
+}
 
 base::MessageLoopProxy* PpapiThread::GetIPCMessageLoop() {
   return ChildProcess::current()->io_message_loop_proxy();
 }
 
 base::WaitableEvent* PpapiThread::GetShutdownEvent() {
   return ChildProcess::current()->GetShutDownEvent();
 }
 
+IPC::PlatformFileForTransit PpapiThread::ShareHandleWithRemote(

[jschuh, 2012/05/10 00:10:57]

Here's the handle duping logic.

+    base::PlatformFile handle,
+    const IPC::SyncChannel& channel,
+    bool should_close_source) {
+  IPC::PlatformFileForTransit out_handle;
+  if (peer_handle_) {
+    DCHECK(is_broker_);
+    return IPC::GetFileHandleForProcess(handle, peer_handle_,
+                                        should_close_source);
+  } else {
+    DCHECK(!is_broker_);
+    return content::BrokerGetFileHandleForProcess(handle, channel.peer_pid(),
+                                                  should_close_source);
+  }
+  return out_handle;
+}
+
 std::set<PP_Instance>* PpapiThread::GetGloballySeenInstanceIDSet() {
   return &globally_seen_instance_ids_;
 }
 
 bool PpapiThread::SendToBrowser(IPC::Message* msg) {
   return Send(msg);
 }
 
 void PpapiThread::PreCacheFont(const void* logfontw) {
 #if defined(OS_WIN)
@@ skipping 101 matching lines @@
         &ppapi::proxy::PluginDispatcher::GetBrowserInterface);
     if (init_error != PP_OK) {
       LOG(WARNING) << "InitModule failed with error " << init_error;
       return;
     }
   }
 
   library_.Reset(library.Release());
 }
 
-void PpapiThread::OnMsgCreateChannel(base::ProcessHandle host_process_handle,
-                                     int renderer_id,
+void PpapiThread::OnMsgCreateChannel(int renderer_id,
                                      bool incognito) {
   IPC::ChannelHandle channel_handle;
   if (!library_.is_valid() ||  // Plugin couldn't be loaded.
-      !SetupRendererChannel(host_process_handle, renderer_id, incognito,
-                            &channel_handle)) {
+      !SetupRendererChannel(renderer_id, incognito, &channel_handle)) {
     Send(new PpapiHostMsg_ChannelCreated(IPC::ChannelHandle()));
     return;
   }
 
   Send(new PpapiHostMsg_ChannelCreated(channel_handle));
 }
 
 void PpapiThread::OnMsgSetNetworkState(bool online) {
   if (!get_plugin_interface_)
     return;
@@ skipping 10 matching lines @@
   if (!msg.ReadUInt32(&iter, &id)) {
     NOTREACHED();
     return;
   }
   std::map<uint32, ppapi::proxy::PluginDispatcher*>::iterator dispatcher =
       plugin_dispatchers_.find(id);
   if (dispatcher != plugin_dispatchers_.end())
     dispatcher->second->OnMessageReceived(msg);
 }
 
-bool PpapiThread::SetupRendererChannel(base::ProcessHandle host_process_handle,
-                                       int renderer_id,
+bool PpapiThread::SetupRendererChannel(int renderer_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));
 
   ppapi::proxy::ProxyChannel* dispatcher = NULL;
   bool init_result = false;
   if (is_broker_) {
     BrokerProcessDispatcher* broker_dispatcher =
-        new BrokerProcessDispatcher(host_process_handle,
-                                    get_plugin_interface_,
+        new BrokerProcessDispatcher(get_plugin_interface_,
                                     connect_instance_func_);
     init_result = broker_dispatcher->InitBrokerWithChannel(this,
                                                            plugin_handle,
                                                            false);
     dispatcher = broker_dispatcher;
   } else {
     PluginProcessDispatcher* plugin_dispatcher =
-        new PluginProcessDispatcher(host_process_handle, get_plugin_interface_,
-                                    incognito);
+        new PluginProcessDispatcher(get_plugin_interface_, incognito);
     init_result = plugin_dispatcher->InitPluginWithChannel(this,
                                                            plugin_handle,
                                                            false);
     dispatcher = plugin_dispatcher;
   }
 
   if (!init_result) {
     delete dispatcher;
     return false;
   }
@@ skipping 10 matching lines @@
 
   // From here, the dispatcher will manage its own lifetime according to the
   // lifetime of the attached channel.
   return true;
 }
 
 void PpapiThread::SavePluginName(const FilePath& path) {
   ppapi::proxy::PluginGlobals::Get()->set_plugin_name(
       path.BaseName().AsUTF8Unsafe());
 }