ppapi/nacl_irt/ppapi_dispatcher.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/nacl_irt/ppapi_dispatcher.h"
   6
   7 #include <map>
   8 #include <set>
   9
  10 #include "build/build_config.h"
  11 // Need to include this before most other files because it defines
  12 // IPC_MESSAGE_LOG_ENABLED. We need to use it to define
  13 // IPC_MESSAGE_MACROS_LOG_ENABLED so ppapi_messages.h will generate the
  14 // ViewMsgLog et al. functions.
  15
  16 #include "base/command_line.h"
  17 #include "base/memory/ref_counted.h"
  18 #include "base/message_loop/message_loop.h"
  19 #include "base/synchronization/waitable_event.h"
  20 #include "components/tracing/child_trace_message_filter.h"
  21 #include "ipc/ipc_channel_handle.h"
  22 #include "ipc/ipc_logging.h"
  23 #include "ipc/ipc_message.h"
  24 #include "ppapi/c/ppp.h"
  25 #include "ppapi/c/ppp_instance.h"
  26 #include "ppapi/nacl_irt/manifest_service.h"
  27 #include "ppapi/nacl_irt/plugin_startup.h"
  28 #include "ppapi/proxy/plugin_dispatcher.h"
  29 #include "ppapi/proxy/plugin_globals.h"
  30 #include "ppapi/proxy/plugin_message_filter.h"
  31 #include "ppapi/proxy/plugin_proxy_delegate.h"
  32 #include "ppapi/proxy/resource_reply_thread_registrar.h"
  33
  34 #if defined(IPC_MESSAGE_LOG_ENABLED)
  35 #include "base/containers/hash_tables.h"
  36
  37 LogFunctionMap g_log_function_mapping;
  38
  39 #define IPC_MESSAGE_MACROS_LOG_ENABLED
  40 #define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger) \
  41   g_log_function_mapping[msg_id] = logger
  42
  43 #endif
  44 #include "ppapi/proxy/ppapi_messages.h"
  45
  46 namespace ppapi {
  47
  48 PpapiDispatcher::PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop,
  49                                  base::WaitableEvent* shutdown_event,
  50                                  int browser_ipc_fd,
  51                                  int renderer_ipc_fd)
  52     : next_plugin_dispatcher_id_(0),
  53       message_loop_(io_loop),
  54       shutdown_event_(shutdown_event),
  55       renderer_ipc_fd_(renderer_ipc_fd) {
  56 #if defined(IPC_MESSAGE_LOG_ENABLED)
  57   IPC::Logging::set_log_function_map(&g_log_function_mapping);
  58 #endif
  59
  60   IPC::ChannelHandle channel_handle(
  61       "NaCl IPC", base::FileDescriptor(browser_ipc_fd, false));
  62
  63   // Delay initializing the SyncChannel until after we add filters. This
  64   // ensures that the filters won't miss any messages received by
  65   // the channel.
  66   channel_ =
  67       IPC::SyncChannel::Create(this, GetIPCMessageLoop(), GetShutdownEvent());
  68   channel_->AddFilter(new proxy::PluginMessageFilter(
  69       NULL, proxy::PluginGlobals::Get()->resource_reply_thread_registrar()));
  70   channel_->AddFilter(
  71       new tracing::ChildTraceMessageFilter(message_loop_.get()));
  72   channel_->Init(channel_handle, IPC::Channel::MODE_SERVER, true);
  73 }
  74
  75 base::MessageLoopProxy* PpapiDispatcher::GetIPCMessageLoop() {
  76   return message_loop_.get();
  77 }
  78
  79 base::WaitableEvent* PpapiDispatcher::GetShutdownEvent() {
  80   return shutdown_event_;
  81 }
  82
  83 IPC::PlatformFileForTransit PpapiDispatcher::ShareHandleWithRemote(
  84     base::PlatformFile handle,
  85     base::ProcessId peer_pid,
  86     bool should_close_source) {
  87   return IPC::InvalidPlatformFileForTransit();
  88 }
  89
  90 std::set<PP_Instance>* PpapiDispatcher::GetGloballySeenInstanceIDSet() {
  91   return &instances_;
  92 }
  93
  94 uint32 PpapiDispatcher::Register(proxy::PluginDispatcher* plugin_dispatcher) {
  95   if (!plugin_dispatcher ||
  96       plugin_dispatchers_.size() >= std::numeric_limits<uint32>::max()) {
  97     return 0;
  98   }
  99
 100   uint32 id = 0;
 101   do {
 102     // Although it is unlikely, make sure that we won't cause any trouble
 103     // when the counter overflows.
 104     id = next_plugin_dispatcher_id_++;
 105   } while (id == 0 ||
 106            plugin_dispatchers_.find(id) != plugin_dispatchers_.end());
 107   plugin_dispatchers_[id] = plugin_dispatcher;
 108   return id;
 109 }
 110
 111 void PpapiDispatcher::Unregister(uint32 plugin_dispatcher_id) {
 112   plugin_dispatchers_.erase(plugin_dispatcher_id);
 113 }
 114
 115 IPC::Sender* PpapiDispatcher::GetBrowserSender() {
 116   return this;
 117 }
 118
 119 std::string PpapiDispatcher::GetUILanguage() {
 120   NOTIMPLEMENTED();
 121   return std::string();
 122 }
 123
 124 void PpapiDispatcher::PreCacheFont(const void* logfontw) {
 125   NOTIMPLEMENTED();
 126 }
 127
 128 void PpapiDispatcher::SetActiveURL(const std::string& url) {
 129   NOTIMPLEMENTED();
 130 }
 131
 132 PP_Resource PpapiDispatcher::CreateBrowserFont(
 133     proxy::Connection connection,
 134     PP_Instance instance,
 135     const PP_BrowserFont_Trusted_Description& desc,
 136     const Preferences& prefs) {
 137   NOTIMPLEMENTED();
 138   return 0;
 139 }
 140
 141 bool PpapiDispatcher::OnMessageReceived(const IPC::Message& msg) {
 142   IPC_BEGIN_MESSAGE_MAP(PpapiDispatcher, msg)
 143     IPC_MESSAGE_HANDLER(PpapiMsg_InitializeNaClDispatcher,
 144                         OnMsgInitializeNaClDispatcher)
 145     // All other messages are simply forwarded to a PluginDispatcher.
 146     IPC_MESSAGE_UNHANDLED(OnPluginDispatcherMessageReceived(msg))
 147   IPC_END_MESSAGE_MAP()
 148   return true;
 149 }
 150
 151 void PpapiDispatcher::OnChannelError() {
 152   exit(1);
 153 }
 154
 155 bool PpapiDispatcher::Send(IPC::Message* msg) {
 156   return channel_->Send(msg);
 157 }
 158
 159 void PpapiDispatcher::OnMsgInitializeNaClDispatcher(
 160     const PpapiNaClPluginArgs& args) {
 161   static bool command_line_and_logging_initialized = false;
 162   if (command_line_and_logging_initialized) {
 163     LOG(FATAL) << "InitializeNaClDispatcher must be called once per plugin.";
 164     return;
 165   }
 166
 167   command_line_and_logging_initialized = true;
 168   base::CommandLine::Init(0, NULL);
 169   for (size_t i = 0; i < args.switch_names.size(); ++i) {
 170     DCHECK(i < args.switch_values.size());
 171     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 172         args.switch_names[i], args.switch_values[i]);
 173   }
 174   logging::LoggingSettings settings;
 175   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 176   logging::InitLogging(settings);
 177
 178   proxy::PluginGlobals::Get()->set_keepalive_throttle_interval_milliseconds(
 179       args.keepalive_throttle_interval_milliseconds);
 180
 181   // Tell the process-global GetInterface which interfaces it can return to the
 182   // plugin.
 183   proxy::InterfaceList::SetProcessGlobalPermissions(args.permissions);
 184
 185   int32_t error = ::PPP_InitializeModule(
 186       0 /* module */,
 187       &proxy::PluginDispatcher::GetBrowserInterface);
 188   if (error)
 189     ::exit(error);
 190
 191   proxy::PluginDispatcher* dispatcher =
 192       new proxy::PluginDispatcher(::PPP_GetInterface, args.permissions,
 193                                   args.off_the_record);
 194   IPC::ChannelHandle channel_handle(
 195       "nacl",
 196       base::FileDescriptor(renderer_ipc_fd_, false));
 197   if (!dispatcher->InitPluginWithChannel(this, base::kNullProcessId,
 198                                          channel_handle, false)) {
 199     delete dispatcher;
 200     return;
 201   }
 202   // From here, the dispatcher will manage its own lifetime according to the
 203   // lifetime of the attached channel.
 204
 205   // Notify the renderer process, if necessary.
 206   ManifestService* manifest_service = GetManifestService();
 207   if (manifest_service)
 208     manifest_service->StartupInitializationComplete();
 209 }
 210
 211 void PpapiDispatcher::OnPluginDispatcherMessageReceived(
 212     const IPC::Message& msg) {
 213   // The first parameter should be a plugin dispatcher ID.
 214   PickleIterator iter(msg);
 215   uint32 id = 0;
 216   if (!iter.ReadUInt32(&id)) {
 217     NOTREACHED();
 218     return;
 219   }
 220   std::map<uint32, proxy::PluginDispatcher*>::iterator dispatcher =
 221       plugin_dispatchers_.find(id);
 222   if (dispatcher != plugin_dispatchers_.end())
 223     dispatcher->second->OnMessageReceived(msg);
 224 }
 225
 226 }  // namespace ppapi