Broker out PPAPI handle duplication

content/renderer/pepper/pepper_plugin_delegate_impl.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/renderer/pepper/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
@@ skipping 84 matching lines @@
 namespace content {
 
 namespace {
 
 class HostDispatcherWrapper
     : public webkit::ppapi::PluginDelegate::OutOfProcessProxy {
  public:
   HostDispatcherWrapper() {}
   virtual ~HostDispatcherWrapper() {}
 
-  bool Init(base::ProcessHandle plugin_process_handle,
-            const IPC::ChannelHandle& channel_handle,
+  bool Init(const IPC::ChannelHandle& channel_handle,
             PP_Module pp_module,
             PP_GetInterface_Func local_get_interface,
             const ppapi::Preferences& preferences,
             PepperHungPluginFilter* filter) {
     if (channel_handle.name.empty())
       return false;
 
 #if defined(OS_POSIX)
     DCHECK_NE(-1, channel_handle.socket.fd);
     if (channel_handle.socket.fd == -1)
       return false;
 #endif
 
     dispatcher_delegate_.reset(new PepperProxyChannelDelegateImpl);
     dispatcher_.reset(new ppapi::proxy::HostDispatcher(
-        plugin_process_handle, pp_module, local_get_interface, filter));
+        pp_module, local_get_interface, filter));
 
     if (!dispatcher_->InitHostWithChannel(dispatcher_delegate_.get(),
                                           channel_handle,
                                           true,  // Client.
                                           preferences)) {
       dispatcher_.reset();
       dispatcher_delegate_.reset();
       return false;
     }
     dispatcher_->channel()->SetRestrictDispatchChannelGroup(
@@ skipping 94 matching lines @@
       PepperPluginRegistry::GetInstance()->GetInfoForPlugin(webplugin_info);
   if (!info) {
     *pepper_plugin_was_registered = false;
     return scoped_refptr<webkit::ppapi::PluginModule>();
   } else if (!info->is_out_of_process) {
     // In-process plugin not preloaded, it probably couldn't be initialized.
     return scoped_refptr<webkit::ppapi::PluginModule>();
   }
 
   // Out of process: have the browser start the plugin process for us.
-  base::ProcessHandle plugin_process_handle = base::kNullProcessHandle;
   IPC::ChannelHandle channel_handle;
   int plugin_child_id = 0;
   render_view_->Send(new ViewHostMsg_OpenChannelToPepperPlugin(
-      path, &plugin_process_handle, &channel_handle, &plugin_child_id));
+      path, &channel_handle, &plugin_child_id));
   if (channel_handle.name.empty()) {
     // Couldn't be initialized.
     return scoped_refptr<webkit::ppapi::PluginModule>();
   }
 
   scoped_refptr<PepperHungPluginFilter> hung_filter(
       new PepperHungPluginFilter(path, render_view_->routing_id(),
                                  plugin_child_id));
 
   // Create a new HostDispatcher for the proxying, and hook it to a new
   // PluginModule. Note that AddLiveModule must be called before any early
   // returns since the module's destructor will remove itself.
   module = new webkit::ppapi::PluginModule(info->name, path,
                                            PepperPluginRegistry::GetInstance());
   PepperPluginRegistry::GetInstance()->AddLiveModule(path, module);
   scoped_ptr<HostDispatcherWrapper> dispatcher(new HostDispatcherWrapper);
   if (!dispatcher->Init(
-          plugin_process_handle,
           channel_handle,
           module->pp_module(),
           webkit::ppapi::PluginModule::GetLocalGetInterfaceFunc(),
           GetPreferences(),
           hung_filter.get()))
     return scoped_refptr<webkit::ppapi::PluginModule>();
   module->InitAsProxied(dispatcher.release());
   return module;
 }
 
@@ skipping 19 matching lines @@
   if (!render_view_->Send(msg)) {
     pending_connect_broker_.Remove(request_id);
     return scoped_refptr<PepperBrokerImpl>();
   }
 
   return broker;
 }
 
 void PepperPluginDelegateImpl::OnPpapiBrokerChannelCreated(
     int request_id,
-    base::ProcessHandle broker_process_handle,
     const IPC::ChannelHandle& handle) {
   scoped_refptr<PepperBrokerImpl>* broker_ptr =
       pending_connect_broker_.Lookup(request_id);
   if (broker_ptr) {
     scoped_refptr<PepperBrokerImpl> broker = *broker_ptr;
     pending_connect_broker_.Remove(request_id);
-    broker->OnBrokerChannelConnected(broker_process_handle, handle);
+    broker->OnBrokerChannelConnected(handle);
   } else {
     // There is no broker waiting for this channel. Close it so the broker can
     // clean up and possibly exit.
     // The easiest way to clean it up is to just put it in an object
     // and then close them. This failure case is not performance critical.
     PepperBrokerDispatcherWrapper temp_dispatcher;
-    temp_dispatcher.Init(broker_process_handle, handle);
+    temp_dispatcher.Init(handle);
   }
 }
 
 // Iterates through pending_connect_broker_ to find the broker.
 // Cannot use Lookup() directly because pending_connect_broker_ does not store
 // the raw pointer to the broker. Assumes maximum of one copy of broker exists.
 bool PepperPluginDelegateImpl::StopWaitingForBrokerConnection(
     PepperBrokerImpl* broker) {
   for (BrokerMap::iterator i(&pending_connect_broker_);
        !i.IsAtEnd(); i.Advance()) {
@@ skipping 510 matching lines @@
   virtual void DidFail(base::PlatformFileError error_code) {
     base::PlatformFile invalid_file = base::kInvalidPlatformFileValue;
     callback_.Run(error_code, base::PassPlatformFile(&invalid_file));
   }
 
   virtual void DidWrite(int64 bytes, bool complete) {
     NOTREACHED();
   }
 
   virtual void DidOpenFile(
-      base::PlatformFile file,
-      base::ProcessHandle unused) {
+      base::PlatformFile file) {
     callback_.Run(base::PLATFORM_FILE_OK, base::PassPlatformFile(&file));
     // Make sure we won't leak file handle if the requester has died.
     if (file != base::kInvalidPlatformFileValue) {
       base::FileUtilProxy::Close(
           RenderThreadImpl::current()->GetFileThreadMessageLoopProxy(), file,
           base::FileUtilProxy::StatusCallback());
     }
   }
 
 private:  // TODO(ericu): Delete this?
@@ skipping 776 matching lines @@
     mouse_lock_instances_.erase(it);
   }
 }
 
 webkit_glue::ClipboardClient*
     PepperPluginDelegateImpl::CreateClipboardClient() const {
   return new RendererClipboardClient;
 }
 
 }  // namespace content