Pepper: Clean up PpapiDispatcher parent classes.

ppapi/proxy/plugin_main_nacl.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 <unistd.h>
+
 #include <map>
 #include <set>
 
 #include "build/build_config.h"
 // Need to include this before most other files because it defines
 // IPC_MESSAGE_LOG_ENABLED. We need to use it to define
 // IPC_MESSAGE_MACROS_LOG_ENABLED so ppapi_messages.h will generate the
 // ViewMsgLog et al. functions.
 
 #include "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "components/tracing/child_trace_message_filter.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message.h"
 #include "native_client/src/public/chrome_main.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
@@ skipping 24 matching lines @@
 using ppapi::proxy::PluginGlobals;
 using ppapi::proxy::PluginProxyDelegate;
 using ppapi::proxy::ProxyChannel;
 using ppapi::proxy::SerializedHandle;
 
 namespace {
 
 // This class manages communication between the plugin and the browser, and
 // manages the PluginDispatcher instances for communication between the plugin
 // and the renderer.
-class PpapiDispatcher : public ProxyChannel,
-                        public PluginDispatcher::PluginDelegate,
-                        public PluginProxyDelegate {
+class PpapiDispatcher : public PluginDispatcher::PluginDelegate,
+                        public PluginProxyDelegate,
+                        public IPC::Listener,
+                        public IPC::Sender {
  public:
   explicit PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop);
 
   // PluginDispatcher::PluginDelegate implementation.
   virtual base::MessageLoopProxy* GetIPCMessageLoop() OVERRIDE;
   virtual base::WaitableEvent* GetShutdownEvent() OVERRIDE;
   virtual IPC::PlatformFileForTransit ShareHandleWithRemote(
       base::PlatformFile handle,
       base::ProcessId peer_pid,
       bool should_close_source) OVERRIDE;
   virtual std::set<PP_Instance>* GetGloballySeenInstanceIDSet() OVERRIDE;
   virtual uint32 Register(PluginDispatcher* plugin_dispatcher) OVERRIDE;
   virtual void Unregister(uint32 plugin_dispatcher_id) OVERRIDE;
 
   // PluginProxyDelegate implementation.
   virtual IPC::Sender* GetBrowserSender() OVERRIDE;
   virtual std::string GetUILanguage() OVERRIDE;
   virtual void PreCacheFont(const void* logfontw) OVERRIDE;
   virtual void SetActiveURL(const std::string& url) OVERRIDE;
   virtual PP_Resource CreateBrowserFont(
       ppapi::proxy::Connection connection,
       PP_Instance instance,
       const PP_BrowserFont_Trusted_Description& desc,
       const ppapi::Preferences& prefs) OVERRIDE;
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual void OnChannelError() OVERRIDE;
+
+  // IPC::Sender implementation
+  virtual bool Send(IPC::Message* message) OVERRIDE;
 
  private:
   void OnMsgInitializeNaClDispatcher(const ppapi::PpapiNaClPluginArgs& args);
   void OnPluginDispatcherMessageReceived(const IPC::Message& msg);
 
   void SetPpapiKeepAliveThrottleFromCommandLine();
 
   std::set<PP_Instance> instances_;
   std::map<uint32, PluginDispatcher*> plugin_dispatchers_;
   uint32 next_plugin_dispatcher_id_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   base::WaitableEvent shutdown_event_;
+  scoped_ptr<IPC::SyncChannel> channel_;
 };
 
 PpapiDispatcher::PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop)
     : next_plugin_dispatcher_id_(0),
       message_loop_(io_loop),
       shutdown_event_(true, false) {
   // The first FD (based on NACL_CHROME_DESC_BASE) is the IPC channel to the
   // browser.
   IPC::ChannelHandle channel_handle(
       "NaCl IPC", base::FileDescriptor(NACL_CHROME_DESC_BASE, false));
   // We don't have/need a PID since handle sharing happens outside of the
   // NaCl sandbox.
-  InitWithChannel(this, base::kNullProcessId, channel_handle,
-                  false);  // Channel is server.
-  channel()->AddFilter(new ppapi::proxy::PluginMessageFilter(
+  channel_.reset(new IPC::SyncChannel(
+      channel_handle, IPC::Channel::MODE_SERVER, this,
+      GetIPCMessageLoop(), true, GetShutdownEvent()));
+
+  channel_->AddFilter(new ppapi::proxy::PluginMessageFilter(
       NULL, PluginGlobals::Get()->resource_reply_thread_registrar()));
-  channel()->AddFilter(
+  channel_->AddFilter(
       new tracing::ChildTraceMessageFilter(message_loop_.get()));
 }
 
 base::MessageLoopProxy* PpapiDispatcher::GetIPCMessageLoop() {
   return message_loop_.get();
 }
 
 base::WaitableEvent* PpapiDispatcher::GetShutdownEvent() {
   return &shutdown_event_;
 }
@@ skipping 59 matching lines @@
 bool PpapiDispatcher::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(PpapiDispatcher, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_InitializeNaClDispatcher,
                         OnMsgInitializeNaClDispatcher)
     // All other messages are simply forwarded to a PluginDispatcher.
     IPC_MESSAGE_UNHANDLED(OnPluginDispatcherMessageReceived(msg))
   IPC_END_MESSAGE_MAP()
   return true;
 }
 
+void PpapiDispatcher::OnChannelError() {
+  exit(1);
+}
+
+bool PpapiDispatcher::Send(IPC::Message* msg) {
+  return channel_->Send(msg);
+}
+
 void PpapiDispatcher::OnMsgInitializeNaClDispatcher(
     const ppapi::PpapiNaClPluginArgs& args) {
   static bool command_line_and_logging_initialized = false;
   if (command_line_and_logging_initialized) {
     LOG(FATAL) << "InitializeNaClDispatcher must be called once per plugin.";
     return;
   }
 
   command_line_and_logging_initialized = true;
   CommandLine::Init(0, NULL);
@@ skipping 91 matching lines @@
     return 1;
   }
 
   PpapiDispatcher ppapi_dispatcher(io_thread.message_loop_proxy());
   plugin_globals.set_plugin_proxy_delegate(&ppapi_dispatcher);
 
   loop.Run();
 
   return 0;
 }