Refactoring of new IPC-only pepper implementation

content/renderer/pepper/pepper_in_process_router.cc

Index: content/renderer/pepper/pepper_in_process_router.cc
diff --git a/content/renderer/pepper/pepper_in_process_router.cc b/content/renderer/pepper/pepper_in_process_router.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d40785cae571b4ea66474b0f59d3991357f64609
--- /dev/null
+++ b/content/renderer/pepper/pepper_in_process_router.cc
@@ -0,0 +1,153 @@
+// 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_in_process_router.h"
+
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "content/renderer/pepper/renderer_ppapi_host_impl.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_macros.h"
+#include "ipc/ipc_sender.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/resource_tracker.h"
+
+namespace content {
+
+class PepperInProcessRouter::DummyBrowserChannel : public IPC::Sender {
+ public:
+  DummyBrowserChannel() {}
+  ~DummyBrowserChannel() {}
+
+  // Sender implementation.
+  virtual bool Send(IPC::Message* msg) OVERRIDE {
+    // See the class comment in the header file for what this is about.
+    NOTREACHED();
+    delete msg;
+    return false;
+  }
+};
+
+class PepperInProcessRouter::PluginToHostRouter : public IPC::Sender {
+ public:
+  PluginToHostRouter(RendererPpapiHostImpl* host_impl);
+  virtual ~PluginToHostRouter() {}
+
+  // Sender implementation.
+  virtual bool Send(IPC::Message* msg) OVERRIDE;
+
+ private:
+  void DoSend(IPC::Message* msg);
+
+  RendererPpapiHostImpl* host_impl_;
+
+  base::WeakPtrFactory<PluginToHostRouter> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(PluginToHostRouter);
+};
+
+PepperInProcessRouter::PluginToHostRouter::PluginToHostRouter(
+    RendererPpapiHostImpl* host_impl)
+    : host_impl_(host_impl),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+}
+
+bool PepperInProcessRouter::PluginToHostRouter::Send(
+    IPC::Message* msg) {
+  // Don't directly call into the message handler to avoid reentrancy. The IPC
+  // systen assumes everything is executed from the message loop, so emulate
+  // the same thing for in-process.
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&PluginToHostRouter::DoSend, weak_factory_.GetWeakPtr(),
+                 base::Owned(msg)));
+  return true;
+}
+
+void PepperInProcessRouter::PluginToHostRouter::DoSend(
+    IPC::Message* msg) {
+  host_impl_->GetPpapiHost()->OnMessageReceived(*msg);
+}
+
+// HostToPluginRouter ---------------------------------------------------------
+
+class PepperInProcessRouter::HostToPluginRouter : public IPC::Sender {
+ public:
+  HostToPluginRouter();
+  virtual ~HostToPluginRouter() {}
+
+  // Sender implementation.
+  virtual bool Send(IPC::Message* msg) OVERRIDE;
+
+ private:
+  void DispatchMsg(IPC::Message* msg);
+
+  void OnMsgResourceReply(
+      const ppapi::proxy::ResourceMessageReplyParams& reply_params,
+      const IPC::Message& nested_msg);
+
+  base::WeakPtrFactory<HostToPluginRouter> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(HostToPluginRouter);
+};
+
+PepperInProcessRouter::HostToPluginRouter::HostToPluginRouter()
+    : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+}
+
+bool PepperInProcessRouter::HostToPluginRouter::Send(
+    IPC::Message* msg) {
+  // As in the PluginToHostRouter, dispatch from the message loop.
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&HostToPluginRouter::DispatchMsg,
+                 weak_factory_.GetWeakPtr(),
+                 base::Owned(msg)));
+  return true;
+}
+
+void PepperInProcessRouter::HostToPluginRouter::DispatchMsg(
+    IPC::Message* msg) {
+  // Emulate the proxy by dispatching the relevant message here.
+  IPC_BEGIN_MESSAGE_MAP(HostToPluginRouter, *msg)
+    IPC_MESSAGE_HANDLER(PpapiPluginMsg_ResourceReply, OnMsgResourceReply)
+  IPC_END_MESSAGE_MAP()
+}
+
+void PepperInProcessRouter::HostToPluginRouter::OnMsgResourceReply(
+    const ppapi::proxy::ResourceMessageReplyParams& reply_params,
+    const IPC::Message& nested_msg) {
+  ppapi::Resource* resource =
+      ppapi::PpapiGlobals::Get()->GetResourceTracker()->GetResource(
+          reply_params.pp_resource());
+  if (!resource) {
+    // The resource could have been destroyed while the async processing was
+    // pending. Just drop the message.
+    return;
+  }
+  resource->OnReplyReceived(reply_params, nested_msg);
+}
+
+PepperInProcessRouter::PepperInProcessRouter(
+    RendererPpapiHostImpl* host_impl)
+    : host_to_plugin_router_(new HostToPluginRouter),
+      plugin_to_host_router_(new PluginToHostRouter(host_impl)) {
+}
+
+PepperInProcessRouter::~PepperInProcessRouter() {
+}
+
+IPC::Sender* PepperInProcessRouter::GetPluginToRendererSender() {
+  return plugin_to_host_router_.get();
+}
+
+IPC::Sender* PepperInProcessRouter::GetRendererToPluginSender() {
+  return host_to_plugin_router_.get();
+}
+
+ppapi::proxy::Connection PepperInProcessRouter::GetPluginConnection() {
+  return ppapi::proxy::Connection(dummy_browser_channel_.get(),
+                                  plugin_to_host_router_.get());
+}
+
+}  // namespace content