A few more cleanups to the pepper code. Dispatch IPCs in the sockets implementations directly by ha…

content/renderer/pepper/pepper_helper_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_helper_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
-#include "base/files/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/strings/string_split.h"
 #include "base/sync_socket.h"
 #include "base/time/time.h"
 #include "content/child/child_process.h"
 #include "content/child/npapi/webplugin.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/pepper_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/gamepad_shared_memory_reader.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/pepper/content_renderer_pepper_host_factory.h"
 #include "content/renderer/pepper/host_dispatcher_wrapper.h"
+#include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_broker.h"
 #include "content/renderer/pepper/pepper_browser_connection.h"
 #include "content/renderer/pepper/pepper_file_system_host.h"
 #include "content/renderer/pepper/pepper_graphics_2d_host.h"
 #include "content/renderer/pepper/pepper_hung_plugin_filter.h"
 #include "content/renderer/pepper/pepper_in_process_resource_creation.h"
 #include "content/renderer/pepper/pepper_in_process_router.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/pepper_plugin_registry.h"
 #include "content/renderer/pepper/pepper_url_loader_host.h"
 #include "content/renderer/pepper/pepper_webplugin_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/ppb_tcp_server_socket_private_impl.h"
 #include "content/renderer/pepper/ppb_tcp_socket_private_impl.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
-#include "content/renderer/pepper/resource_helper.h"
 #include "content/renderer/pepper/url_response_info_util.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/webplugin_delegate_proxy.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/video/capture/video_capture_proxy.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 40 matching lines @@
       RendererPpapiHostImpl::CreateOnModuleForInProcess(
           module, perms);
   render_view->PpapiPluginCreated(host_impl);
 }
 
 }  // namespace
 
 PepperHelperImpl::PepperHelperImpl(RenderViewImpl* render_view)
     : RenderViewObserver(render_view),
       render_view_(render_view),
-      pepper_browser_connection_(this),
       focused_plugin_(NULL),
       last_mouse_event_target_(NULL) {
+  new PepperBrowserConnection(render_view);

[scottmg, 2013/08/01 02:45:02]

why allocated and leaked now instead of contained?

[jam, 2013/08/01 06:53:35]

this is a RenderViewObserver which deletes itself when a RenderView goes away.
this way it gets to filter IPCs on its own, and can Send, without going through
this class

 }
 
 PepperHelperImpl::~PepperHelperImpl() {
 }
 
 WebKit::WebPlugin* PepperHelperImpl::CreatePepperWebPlugin(
     const WebPluginInfo& webplugin_info,
     const WebKit::WebPluginParams& params) {
   bool pepper_plugin_was_registered = false;
   scoped_refptr<PluginModule> pepper_module(
@@ skipping 370 matching lines @@
     last_mouse_event_target_ = NULL;
   if (focused_plugin_ == instance)
     PluginFocusChanged(instance, false);
 }
 
 // If a broker has not already been created for this plugin, creates one.
 PepperBroker* PepperHelperImpl::ConnectToBroker(
     PPB_Broker_Impl* client) {
   DCHECK(client);
 
-  PluginModule* plugin_module = ResourceHelper::GetPluginModule(client);
+  PluginModule* plugin_module =
+      HostGlobals::Get()->GetInstance(client->pp_instance())->module();
   if (!plugin_module)
     return NULL;
 
   scoped_refptr<PepperBroker> broker =
       static_cast<PepperBroker*>(plugin_module->GetBroker());
   if (!broker.get())
     broker = CreateBroker(plugin_module);
 
   int request_id = pending_permission_requests_.Add(
       new base::WeakPtr<PPB_Broker_Impl>(client->AsWeakPtr()));
@@ skipping 13 matching lines @@
 void PepperHelperImpl::OnPpapiBrokerPermissionResult(int request_id,
                                                      bool result) {
   scoped_ptr<base::WeakPtr<PPB_Broker_Impl> > client_ptr(
       pending_permission_requests_.Lookup(request_id));
   DCHECK(client_ptr.get());
   pending_permission_requests_.Remove(request_id);
   base::WeakPtr<PPB_Broker_Impl> client = *client_ptr;
   if (!client.get())
     return;
 
-  PluginModule* plugin_module = ResourceHelper::GetPluginModule(client.get());
+  PluginModule* plugin_module =
+      HostGlobals::Get()->GetInstance(client->pp_instance())->module();
   if (!plugin_module)
     return;
 
   PepperBroker* broker = static_cast<PepperBroker*>(plugin_module->GetBroker());
   broker->OnBrokerPermissionResult(client.get(), result);
 }
 
-bool PepperHelperImpl::AsyncOpenFile(const base::FilePath& path,
-                                     int flags,
-                                     const AsyncOpenFileCallback& callback) {
-  int message_id = pending_async_open_files_.Add(
-      new AsyncOpenFileCallback(callback));
-  return Send(new ViewHostMsg_AsyncOpenFile(
-      routing_id(), path, flags, message_id));
-}
-
-void PepperHelperImpl::OnAsyncFileOpened(
-    base::PlatformFileError error_code,
-    IPC::PlatformFileForTransit file_for_transit,
-    int message_id) {
-  AsyncOpenFileCallback* callback =
-      pending_async_open_files_.Lookup(message_id);
-  DCHECK(callback);
-  pending_async_open_files_.Remove(message_id);
-
-  base::PlatformFile file =
-      IPC::PlatformFileForTransitToPlatformFile(file_for_transit);
-  callback->Run(error_code, 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().get(),
-        file,
-        base::FileUtilProxy::StatusCallback());
-  }
-  delete callback;
-}
-
 void PepperHelperImpl::OnSetFocus(bool has_focus) {
   for (std::set<PepperPluginInstanceImpl*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->SetContentAreaFocus(has_focus);
 }
 
 void PepperHelperImpl::PageVisibilityChanged(bool is_visible) {
   for (std::set<PepperPluginInstanceImpl*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->PageVisibilityChanged(is_visible);
 }
 
 bool PepperHelperImpl::IsPluginFocused() const {
   return focused_plugin_ != NULL;
 }
 
 void PepperHelperImpl::WillHandleMouseEvent() {
   // This method is called for every mouse event that the render view receives.
   // And then the mouse event is forwarded to WebKit, which dispatches it to the
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |last_mouse_event_target_| to NULL here. If a plugin gets the
   // event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |last_mouse_event_target_|.
   last_mouse_event_target_ = NULL;
 }
 
-void PepperHelperImpl::RegisterTCPSocket(
-    PPB_TCPSocket_Private_Impl* socket,
-    uint32 socket_id) {
-  tcp_sockets_.AddWithID(socket, socket_id);
-}
-
-void PepperHelperImpl::UnregisterTCPSocket(uint32 socket_id) {
-  // There is no DCHECK(tcp_sockets_.Lookup(socket_id)) because this method
-  // can be called before TCPSocketConnect or TCPSocketConnectWithNetAddress.
-  if (tcp_sockets_.Lookup(socket_id))
-    tcp_sockets_.Remove(socket_id);
-}
-
-void PepperHelperImpl::TCPServerSocketStopListening(uint32 socket_id) {
-  tcp_server_sockets_.Remove(socket_id);
-}
-
 void PepperHelperImpl::HandleDocumentLoad(
     PepperPluginInstanceImpl* instance,
     const WebKit::WebURLResponse& response) {
   DCHECK(!instance->document_loader());
 
   PP_Instance pp_instance = instance->pp_instance();
   RendererPpapiHostImpl* host_impl = instance->module()->renderer_ppapi_host();
 
   // Create a loader resource host for this load. Note that we have to set
   // the document_loader before issuing the in-process
@@ skipping 78 matching lines @@
   last_mouse_event_target_ = instance;
 }
 
 void PepperHelperImpl::SampleGamepads(WebKit::WebGamepads* data) {
   if (!gamepad_shared_memory_reader_)
     gamepad_shared_memory_reader_.reset(new GamepadSharedMemoryReader);
   gamepad_shared_memory_reader_->SampleGamepads(*data);
 }
 
 bool PepperHelperImpl::OnMessageReceived(const IPC::Message& message) {
-  if (pepper_browser_connection_.OnMessageReceived(message))
-    return true;
-
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PepperHelperImpl, message)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ConnectACK,
-                        OnTCPSocketConnectACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,
-                        OnTCPSocketSSLHandshakeACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ReadACK, OnTCPSocketReadACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_WriteACK, OnTCPSocketWriteACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SetOptionACK,
-                        OnTCPSocketSetOptionACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_ListenACK,
-                        OnTCPServerSocketListenACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_AcceptACK,
-                        OnTCPServerSocketAcceptACK)
     IPC_MESSAGE_HANDLER(ViewMsg_PpapiBrokerChannelCreated,
                         OnPpapiBrokerChannelCreated)
-    IPC_MESSAGE_HANDLER(ViewMsg_AsyncOpenFile_ACK, OnAsyncFileOpened)
     IPC_MESSAGE_HANDLER(ViewMsg_PpapiBrokerPermissionResult,
                         OnPpapiBrokerPermissionResult)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PepperHelperImpl::OnDestruct() {
   // Nothing to do here. Default implementation in RenderViewObserver does
   // 'delete this' but it's not suitable for PepperHelperImpl because
   // it's non-pointer member in RenderViewImpl.
 }
 
-void PepperHelperImpl::OnTCPSocketConnectACK(
-    uint32 plugin_dispatcher_id,
-    uint32 socket_id,
-    int32_t result,
-    const PP_NetAddress_Private& local_addr,
-    const PP_NetAddress_Private& remote_addr) {
-  PPB_TCPSocket_Private_Impl* socket = tcp_sockets_.Lookup(socket_id);
-  if (socket)
-    socket->OnConnectCompleted(result, local_addr, remote_addr);
-  if (result != PP_OK)
-    tcp_sockets_.Remove(socket_id);
-}
-
-void PepperHelperImpl::OnTCPSocketSSLHandshakeACK(
-    uint32 plugin_dispatcher_id,
-    uint32 socket_id,
-    bool succeeded,
-    const ppapi::PPB_X509Certificate_Fields& certificate_fields) {
-  PPB_TCPSocket_Private_Impl* socket = tcp_sockets_.Lookup(socket_id);
-  if (socket)
-    socket->OnSSLHandshakeCompleted(succeeded, certificate_fields);
-}
-
-void PepperHelperImpl::OnTCPSocketReadACK(uint32 plugin_dispatcher_id,
-                                          uint32 socket_id,
-                                          int32_t result,
-                                          const std::string& data) {
-  PPB_TCPSocket_Private_Impl* socket = tcp_sockets_.Lookup(socket_id);
-  if (socket)
-    socket->OnReadCompleted(result, data);
-}
-
-void PepperHelperImpl::OnTCPSocketWriteACK(uint32 plugin_dispatcher_id,
-                                           uint32 socket_id,
-                                           int32_t result) {
-  PPB_TCPSocket_Private_Impl* socket = tcp_sockets_.Lookup(socket_id);
-  if (socket)
-    socket->OnWriteCompleted(result);
-}
-
-void PepperHelperImpl::OnTCPSocketSetOptionACK(
-    uint32 plugin_dispatcher_id,
-    uint32 socket_id,
-    int32_t result) {
-  PPB_TCPSocket_Private_Impl* socket = tcp_sockets_.Lookup(socket_id);
-  if (socket)
-    socket->OnSetOptionCompleted(result);
-}
-
-void PepperHelperImpl::OnTCPServerSocketListenACK(
-    uint32 plugin_dispatcher_id,
-    PP_Resource socket_resource,
-    uint32 socket_id,
-    const PP_NetAddress_Private& local_addr,
-    int32_t status) {
-  ppapi::thunk::EnterResource<ppapi::thunk::PPB_TCPServerSocket_Private_API>
-      enter(socket_resource, true);
-  if (enter.succeeded()) {
-    ppapi::PPB_TCPServerSocket_Shared* socket =
-        static_cast<ppapi::PPB_TCPServerSocket_Shared*>(enter.object());
-    if (status == PP_OK)
-      tcp_server_sockets_.AddWithID(socket, socket_id);
-    socket->OnListenCompleted(socket_id, local_addr, status);
-  } else if (socket_id != 0 && status == PP_OK) {
-    // StopListening was called before completion of Listen.
-    Send(new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id));
-  }
-}
-
-void PepperHelperImpl::OnTCPServerSocketAcceptACK(
-    uint32 plugin_dispatcher_id,
-    uint32 server_socket_id,
-    uint32 accepted_socket_id,
-    const PP_NetAddress_Private& local_addr,
-    const PP_NetAddress_Private& remote_addr) {
-  ppapi::PPB_TCPServerSocket_Shared* socket =
-      tcp_server_sockets_.Lookup(server_socket_id);
-  if (socket) {
-    bool succeeded = (accepted_socket_id != 0);
-    socket->OnAcceptCompleted(succeeded,
-                              accepted_socket_id,
-                              local_addr,
-                              remote_addr);
-  } else if (accepted_socket_id != 0) {
-    Send(new PpapiHostMsg_PPBTCPSocket_Disconnect(accepted_socket_id));
-  }
-}
-
 }  // namespace content