1// Copyright (c) 2012 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 "content/renderer/pepper/plugin_module.h"
6
7#include <set>
8
9#include "base/bind.h"
10#include "base/command_line.h"
11#include "base/logging.h"
12#include "base/memory/scoped_ptr.h"
13#include "base/message_loop/message_loop.h"
14#include "base/message_loop/message_loop_proxy.h"
15#include "base/time/time.h"
16#include "build/build_config.h"
17#include "content/common/view_messages.h"
18#include "content/public/renderer/content_renderer_client.h"
19#include "content/renderer/pepper/common.h"
20#include "content/renderer/pepper/host_dispatcher_wrapper.h"
21#include "content/renderer/pepper/host_globals.h"
22#include "content/renderer/pepper/pepper_hung_plugin_filter.h"
23#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
24#include "content/renderer/pepper/pepper_plugin_registry.h"
25#include "content/renderer/pepper/ppb_image_data_impl.h"
26#include "content/renderer/pepper/ppb_proxy_impl.h"
27#include "content/renderer/pepper/ppb_scrollbar_impl.h"
28#include "content/renderer/pepper/ppb_var_deprecated_impl.h"
29#include "content/renderer/pepper/ppb_video_decoder_impl.h"
30#include "content/renderer/pepper/renderer_ppapi_host_impl.h"
31#include "content/renderer/render_view_impl.h"
32#include "ppapi/c/dev/ppb_audio_input_dev.h"
33#include "ppapi/c/dev/ppb_buffer_dev.h"
34#include "ppapi/c/dev/ppb_char_set_dev.h"
35#include "ppapi/c/dev/ppb_crypto_dev.h"
36#include "ppapi/c/dev/ppb_cursor_control_dev.h"
37#include "ppapi/c/dev/ppb_device_ref_dev.h"
38#include "ppapi/c/dev/ppb_file_chooser_dev.h"
39#include "ppapi/c/dev/ppb_font_dev.h"
40#include "ppapi/c/dev/ppb_gles_chromium_texture_mapping_dev.h"
41#include "ppapi/c/dev/ppb_memory_dev.h"
42#include "ppapi/c/dev/ppb_opengles2ext_dev.h"
43#include "ppapi/c/dev/ppb_printing_dev.h"
44#include "ppapi/c/dev/ppb_scrollbar_dev.h"
45#include "ppapi/c/dev/ppb_text_input_dev.h"
46#include "ppapi/c/dev/ppb_trace_event_dev.h"
47#include "ppapi/c/dev/ppb_truetype_font_dev.h"
48#include "ppapi/c/dev/ppb_url_util_dev.h"
49#include "ppapi/c/dev/ppb_var_deprecated.h"
50#include "ppapi/c/dev/ppb_video_capture_dev.h"
51#include "ppapi/c/dev/ppb_video_decoder_dev.h"
52#include "ppapi/c/dev/ppb_view_dev.h"
53#include "ppapi/c/dev/ppb_widget_dev.h"
54#include "ppapi/c/dev/ppb_zoom_dev.h"
55#include "ppapi/c/pp_module.h"
56#include "ppapi/c/pp_resource.h"
57#include "ppapi/c/pp_var.h"
58#include "ppapi/c/ppb_audio.h"
59#include "ppapi/c/ppb_audio_buffer.h"
60#include "ppapi/c/ppb_audio_config.h"
61#include "ppapi/c/ppb_compositor.h"
62#include "ppapi/c/ppb_compositor_layer.h"
63#include "ppapi/c/ppb_console.h"
64#include "ppapi/c/ppb_core.h"
65#include "ppapi/c/ppb_file_io.h"
66#include "ppapi/c/ppb_file_mapping.h"
67#include "ppapi/c/ppb_file_ref.h"
68#include "ppapi/c/ppb_file_system.h"
69#include "ppapi/c/ppb_fullscreen.h"
70#include "ppapi/c/ppb_graphics_2d.h"
71#include "ppapi/c/ppb_graphics_3d.h"
72#include "ppapi/c/ppb_host_resolver.h"
73#include "ppapi/c/ppb_image_data.h"
74#include "ppapi/c/ppb_instance.h"
75#include "ppapi/c/ppb_media_stream_audio_track.h"
76#include "ppapi/c/ppb_media_stream_video_track.h"
77#include "ppapi/c/ppb_messaging.h"
78#include "ppapi/c/ppb_mouse_cursor.h"
79#include "ppapi/c/ppb_mouse_lock.h"
80#include "ppapi/c/ppb_net_address.h"
81#include "ppapi/c/ppb_network_list.h"
82#include "ppapi/c/ppb_network_monitor.h"
83#include "ppapi/c/ppb_network_proxy.h"
84#include "ppapi/c/ppb_opengles2.h"
85#include "ppapi/c/ppb_tcp_socket.h"
86#include "ppapi/c/ppb_text_input_controller.h"
87#include "ppapi/c/ppb_udp_socket.h"
88#include "ppapi/c/ppb_url_loader.h"
89#include "ppapi/c/ppb_url_request_info.h"
90#include "ppapi/c/ppb_url_response_info.h"
91#include "ppapi/c/ppb_var.h"
92#include "ppapi/c/ppb_var_array.h"
93#include "ppapi/c/ppb_var_array_buffer.h"
94#include "ppapi/c/ppb_var_dictionary.h"
95#include "ppapi/c/ppb_video_decoder.h"
96#include "ppapi/c/ppb_video_frame.h"
97#include "ppapi/c/ppb_view.h"
98#include "ppapi/c/ppp.h"
99#include "ppapi/c/ppp_instance.h"
100#include "ppapi/c/private/ppb_ext_crx_file_system_private.h"
101#include "ppapi/c/private/ppb_file_io_private.h"
102#include "ppapi/c/private/ppb_file_ref_private.h"
103#include "ppapi/c/private/ppb_find_private.h"
104#include "ppapi/c/private/ppb_flash.h"
105#include "ppapi/c/private/ppb_flash_clipboard.h"
106#include "ppapi/c/private/ppb_flash_device_id.h"
107#include "ppapi/c/private/ppb_flash_drm.h"
108#include "ppapi/c/private/ppb_flash_file.h"
109#include "ppapi/c/private/ppb_flash_font_file.h"
110#include "ppapi/c/private/ppb_flash_fullscreen.h"
111#include "ppapi/c/private/ppb_flash_menu.h"
112#include "ppapi/c/private/ppb_flash_message_loop.h"
113#include "ppapi/c/private/ppb_flash_print.h"
114#include "ppapi/c/private/ppb_host_resolver_private.h"
115#include "ppapi/c/private/ppb_input_event_private.h"
116#include "ppapi/c/private/ppb_instance_private.h"
117#include "ppapi/c/private/ppb_isolated_file_system_private.h"
118#include "ppapi/c/private/ppb_output_protection_private.h"
119#include "ppapi/c/private/ppb_pdf.h"
120#include "ppapi/c/private/ppb_proxy_private.h"
121#include "ppapi/c/private/ppb_talk_private.h"
122#include "ppapi/c/private/ppb_tcp_server_socket_private.h"
123#include "ppapi/c/private/ppb_tcp_socket_private.h"
124#include "ppapi/c/private/ppb_testing_private.h"
125#include "ppapi/c/private/ppb_udp_socket_private.h"
126#include "ppapi/c/private/ppb_uma_private.h"
127#include "ppapi/c/private/ppb_video_destination_private.h"
128#include "ppapi/c/private/ppb_video_source_private.h"
129#include "ppapi/c/private/ppb_x509_certificate_private.h"
130#include "ppapi/c/trusted/ppb_broker_trusted.h"
131#include "ppapi/c/trusted/ppb_browser_font_trusted.h"
132#include "ppapi/c/trusted/ppb_char_set_trusted.h"
133#include "ppapi/c/trusted/ppb_file_chooser_trusted.h"
134#include "ppapi/c/trusted/ppb_url_loader_trusted.h"
135#include "ppapi/shared_impl/callback_tracker.h"
136#include "ppapi/shared_impl/ppapi_preferences.h"
137#include "ppapi/shared_impl/ppapi_switches.h"
138#include "ppapi/shared_impl/ppb_input_event_shared.h"
139#include "ppapi/shared_impl/ppb_opengles2_shared.h"
140#include "ppapi/shared_impl/ppb_var_shared.h"
141#include "ppapi/shared_impl/time_conversion.h"
142#include "ppapi/thunk/enter.h"
143#include "ppapi/thunk/ppb_graphics_2d_api.h"
144#include "ppapi/thunk/thunk.h"
145
146#if defined(OS_CHROMEOS)
147#include "ppapi/c/private/ppb_platform_verification_private.h"
148#endif
149
150using ppapi::InputEventData;
151using ppapi::PpapiGlobals;
152using ppapi::TimeTicksToPPTimeTicks;
153using ppapi::TimeToPPTime;
154using ppapi::thunk::EnterResource;
155using ppapi::thunk::PPB_Graphics2D_API;
156using ppapi::thunk::PPB_InputEvent_API;
157
158namespace content {
159
160namespace {
161
162// Global tracking info for PPAPI plugins. This is lazily created before the
163// first plugin is allocated, and leaked on shutdown.
164//
165// Note that we don't want a Singleton here since destroying this object will
166// try to free some stuff that requires WebKit, and Singletons are destroyed
167// after WebKit.
168// TODO(raymes): I'm not sure if it is completely necessary to leak the
169// HostGlobals. Figure out the shutdown sequence and find a way to do this
170// more elegantly.
171HostGlobals* host_globals = NULL;
172
173// Maintains all currently loaded plugin libs for validating PP_Module
174// identifiers.
175typedef std::set<PluginModule*> PluginModuleSet;
176
177PluginModuleSet* GetLivePluginSet() {
178  CR_DEFINE_STATIC_LOCAL(PluginModuleSet, live_plugin_libs, ());
179  return &live_plugin_libs;
180}
181
182// PPB_Core --------------------------------------------------------------------
183
184void AddRefResource(PP_Resource resource) {
185  PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(resource);
186}
187
188void ReleaseResource(PP_Resource resource) {
189  PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(resource);
190}
191
192PP_Time GetTime() { return TimeToPPTime(base::Time::Now()); }
193
194PP_TimeTicks GetTickTime() {
195  return TimeTicksToPPTimeTicks(base::TimeTicks::Now());
196}
197
198void CallOnMainThread(int delay_in_msec,
199                      PP_CompletionCallback callback,
200                      int32_t result) {
201  if (callback.func) {
202    PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostDelayedTask(
203        FROM_HERE,
204        base::Bind(callback.func, callback.user_data, result),
205        base::TimeDelta::FromMilliseconds(delay_in_msec));
206  }
207}
208
209PP_Bool IsMainThread() {
210  return BoolToPPBool(PpapiGlobals::Get()
211                          ->GetMainThreadMessageLoop()
212                          ->BelongsToCurrentThread());
213}
214
215const PPB_Core core_interface = {&AddRefResource,   &ReleaseResource,
216                                 &GetTime,          &GetTickTime,
217                                 &CallOnMainThread, &IsMainThread};
218
219// PPB_Testing -----------------------------------------------------------------
220
221PP_Bool ReadImageData(PP_Resource device_context_2d,
222                      PP_Resource image,
223                      const PP_Point* top_left) {
224  EnterResource<PPB_Graphics2D_API> enter(device_context_2d, true);
225  if (enter.failed())
226    return PP_FALSE;
227  return BoolToPPBool(enter.object()->ReadImageData(image, top_left));
228}
229
230void RunMessageLoop(PP_Instance instance) {
231  base::MessageLoop::ScopedNestableTaskAllower allow(
232      base::MessageLoop::current());
233  base::MessageLoop::current()->Run();
234}
235
236void QuitMessageLoop(PP_Instance instance) {
237  base::MessageLoop::current()->QuitNow();
238}
239
240uint32_t GetLiveObjectsForInstance(PP_Instance instance_id) {
241  return HostGlobals::Get()->GetResourceTracker()->GetLiveObjectsForInstance(
242      instance_id);
243}
244
245PP_Bool IsOutOfProcess() { return PP_FALSE; }
246
247void SimulateInputEvent(PP_Instance instance, PP_Resource input_event) {
248  PepperPluginInstanceImpl* plugin_instance =
249      host_globals->GetInstance(instance);
250  if (!plugin_instance)
251    return;
252
253  EnterResource<PPB_InputEvent_API> enter(input_event, false);
254  if (enter.failed())
255    return;
256
257  const InputEventData& input_event_data = enter.object()->GetInputEventData();
258  plugin_instance->SimulateInputEvent(input_event_data);
259}
260
261PP_Var GetDocumentURL(PP_Instance instance, PP_URLComponents_Dev* components) {
262  PepperPluginInstanceImpl* plugin_instance =
263      host_globals->GetInstance(instance);
264  if (!plugin_instance)
265    return PP_MakeUndefined();
266  return plugin_instance->GetDocumentURL(instance, components);
267}
268
269uint32_t GetLiveVars(PP_Var live_vars[], uint32_t array_size) {
270  std::vector<PP_Var> vars =
271      PpapiGlobals::Get()->GetVarTracker()->GetLiveVars();
272  for (size_t i = 0u;
273       i < std::min(static_cast<size_t>(array_size), vars.size());
274       ++i)
275    live_vars[i] = vars[i];
276  return vars.size();
277}
278
279void SetMinimumArrayBufferSizeForShmem(PP_Instance /*instance*/,
280                                       uint32_t /*threshold*/) {
281  // Does nothing. Not needed in-process.
282}
283
284const PPB_Testing_Private testing_interface = {
285    &ReadImageData,                    &RunMessageLoop,
286    &QuitMessageLoop,                  &GetLiveObjectsForInstance,
287    &IsOutOfProcess,                   &SimulateInputEvent,
288    &GetDocumentURL,                   &GetLiveVars,
289    &SetMinimumArrayBufferSizeForShmem};
290
291// GetInterface ----------------------------------------------------------------
292
293const void* InternalGetInterface(const char* name) {
294  // Allow custom interface factories first stab at the GetInterface call.
295  const void* custom_interface =
296      GetContentClient()->renderer()->CreatePPAPIInterface(name);
297  if (custom_interface)
298    return custom_interface;
299
300// TODO(brettw) put these in a hash map for better performance.
301#define PROXIED_IFACE(iface_str, iface_struct) \
302  if (strcmp(name, iface_str) == 0)            \
303    return ppapi::thunk::Get##iface_struct##_Thunk();
304
305#include "ppapi/thunk/interfaces_ppb_private.h"
306#include "ppapi/thunk/interfaces_ppb_private_flash.h"
307#include "ppapi/thunk/interfaces_ppb_private_no_permissions.h"
308#include "ppapi/thunk/interfaces_ppb_public_dev.h"
309#include "ppapi/thunk/interfaces_ppb_public_dev_channel.h"
310#include "ppapi/thunk/interfaces_ppb_public_stable.h"
311
312#undef PROXIED_IFACE
313
314#define LEGACY_IFACE(iface_str, function_name) \
315  if (strcmp(name, iface_str) == 0)            \
316    return function_name;
317
318#include "ppapi/thunk/interfaces_legacy.h"
319
320#undef LEGACY_IFACE
321
322  // Only support the testing interface when the command line switch is
323  // specified. This allows us to prevent people from (ab)using this interface
324  // in production code.
325  if (CommandLine::ForCurrentProcess()->HasSwitch(
326          switches::kEnablePepperTesting)) {
327    if (strcmp(name, PPB_TESTING_PRIVATE_INTERFACE) == 0)
328      return &testing_interface;
329  }
330  return NULL;
331}
332
333const void* GetInterface(const char* name) {
334  // All interfaces should be used on the main thread.
335  CHECK(IsMainThread());
336
337  return InternalGetInterface(name);
338}
339
340// Gets the PPAPI entry points from the given library and places them into the
341// given structure. Returns true on success.
342bool LoadEntryPointsFromLibrary(const base::NativeLibrary& library,
343                                PepperPluginInfo::EntryPoints* entry_points) {
344  entry_points->get_interface =
345      reinterpret_cast<PepperPluginInfo::GetInterfaceFunc>(
346          base::GetFunctionPointerFromNativeLibrary(library,
347                                                    "PPP_GetInterface"));
348  if (!entry_points->get_interface) {
349    LOG(WARNING) << "No PPP_GetInterface in plugin library";
350    return false;
351  }
352
353  entry_points->initialize_module =
354      reinterpret_cast<PepperPluginInfo::PPP_InitializeModuleFunc>(
355          base::GetFunctionPointerFromNativeLibrary(library,
356                                                    "PPP_InitializeModule"));
357  if (!entry_points->initialize_module) {
358    LOG(WARNING) << "No PPP_InitializeModule in plugin library";
359    return false;
360  }
361
362  // It's okay for PPP_ShutdownModule to not be defined and shutdown_module to
363  // be NULL.
364  entry_points->shutdown_module =
365      reinterpret_cast<PepperPluginInfo::PPP_ShutdownModuleFunc>(
366          base::GetFunctionPointerFromNativeLibrary(library,
367                                                    "PPP_ShutdownModule"));
368
369  return true;
370}
371
372void CreateHostForInProcessModule(RenderFrameImpl* render_frame,
373                                  PluginModule* module,
374                                  const WebPluginInfo& webplugin_info) {
375  // First time an in-process plugin was used, make a host for it.
376  const PepperPluginInfo* info =
377      PepperPluginRegistry::GetInstance()->GetInfoForPlugin(webplugin_info);
378  DCHECK(!info->is_out_of_process);
379
380  ppapi::PpapiPermissions perms(PepperPluginRegistry::GetInstance()
381                                    ->GetInfoForPlugin(webplugin_info)
382                                    ->permissions);
383  RendererPpapiHostImpl* host_impl =
384      RendererPpapiHostImpl::CreateOnModuleForInProcess(module, perms);
385  render_frame->PepperPluginCreated(host_impl);
386}
387
388}  // namespace
389
390// PluginModule ----------------------------------------------------------------
391
392PluginModule::PluginModule(const std::string& name,
393                           const base::FilePath& path,
394                           const ppapi::PpapiPermissions& perms)
395    : callback_tracker_(new ppapi::CallbackTracker),
396      is_in_destructor_(false),
397      is_crashed_(false),
398      broker_(NULL),
399      library_(NULL),
400      name_(name),
401      path_(path),
402      permissions_(ppapi::PpapiPermissions::GetForCommandLine(perms.GetBits())),
403      reserve_instance_id_(NULL) {
404  // Ensure the globals object is created.
405  if (!host_globals)
406    host_globals = new HostGlobals;
407
408  memset(&entry_points_, 0, sizeof(entry_points_));
409  pp_module_ = HostGlobals::Get()->AddModule(this);
410  GetLivePluginSet()->insert(this);
411}
412
413PluginModule::~PluginModule() {
414  // In the past there have been crashes reentering the plugin module
415  // destructor. Catch if that happens again earlier.
416  CHECK(!is_in_destructor_);
417  is_in_destructor_ = true;
418
419  // When the module is being deleted, there should be no more instances still
420  // holding a reference to us.
421  DCHECK(instances_.empty());
422
423  // Some resources and other stuff are hung off of the embedder state, which
424  // should be torn down before the routing stuff below.
425  renderer_ppapi_host_.reset();
426
427  GetLivePluginSet()->erase(this);
428
429  callback_tracker_->AbortAll();
430
431  if (entry_points_.shutdown_module)
432    entry_points_.shutdown_module();
433
434  if (library_)
435    base::UnloadNativeLibrary(library_);
436
437  // Notifications that we've been deleted should be last.
438  HostGlobals::Get()->ModuleDeleted(pp_module_);
439  if (!is_crashed_) {
440    // When the plugin crashes, we immediately tell the lifetime delegate that
441    // we're gone, so we don't want to tell it again.
442    PepperPluginRegistry::GetInstance()->PluginModuleDead(this);
443  }
444
445  // Don't add stuff here, the two notifications that the module object has
446  // been deleted should be last. This allows, for example,
447  // PPB_Proxy.IsInModuleDestructor to map PP_Module to this class during the
448  // previous parts of the destructor.
449}
450
451void PluginModule::SetRendererPpapiHost(
452    scoped_ptr<RendererPpapiHostImpl> host) {
453  renderer_ppapi_host_ = host.Pass();
454}
455
456bool PluginModule::InitAsInternalPlugin(
457    const PepperPluginInfo::EntryPoints& entry_points) {
458  if (InitializeModule(entry_points)) {
459    entry_points_ = entry_points;
460    return true;
461  }
462  return false;
463}
464
465bool PluginModule::InitAsLibrary(const base::FilePath& path) {
466  base::NativeLibrary library = base::LoadNativeLibrary(path, NULL);
467  if (!library)
468    return false;
469
470  PepperPluginInfo::EntryPoints entry_points;
471
472  if (!LoadEntryPointsFromLibrary(library, &entry_points) ||
473      !InitializeModule(entry_points)) {
474    base::UnloadNativeLibrary(library);
475    return false;
476  }
477  entry_points_ = entry_points;
478  library_ = library;
479  return true;
480}
481
482void PluginModule::InitAsProxied(
483    HostDispatcherWrapper* host_dispatcher_wrapper) {
484  DCHECK(!host_dispatcher_wrapper_.get());
485  host_dispatcher_wrapper_.reset(host_dispatcher_wrapper);
486}
487
488scoped_refptr<PluginModule>
489PluginModule::CreateModuleForExternalPluginInstance() {
490  // Create a new module, but don't set the lifetime delegate. This isn't a
491  // plugin in the usual sense, so it isn't tracked by the browser.
492  scoped_refptr<PluginModule> external_plugin_module(
493      new PluginModule(name_, path_, permissions_));
494  return external_plugin_module;
495}
496
497PP_ExternalPluginResult PluginModule::InitAsProxiedExternalPlugin(
498    PepperPluginInstanceImpl* instance) {
499  DCHECK(host_dispatcher_wrapper_.get());
500  // InitAsProxied (for the trusted/out-of-process case) initializes only the
501  // module, and one or more instances are added later. In this case, the
502  // PluginInstance was already created as in-process, so we missed the proxy
503  // AddInstance step and must do it now.
504  host_dispatcher_wrapper_->AddInstance(instance->pp_instance());
505  // For external plugins, we need to tell the instance to reset itself as
506  // proxied. This will clear cached interface pointers and send DidCreate (etc)
507  // to the plugin side of the proxy.
508  return instance->ResetAsProxied(this);
509}
510
511bool PluginModule::IsProxied() const { return !!host_dispatcher_wrapper_; }
512
513base::ProcessId PluginModule::GetPeerProcessId() {
514  if (host_dispatcher_wrapper_)
515    return host_dispatcher_wrapper_->peer_pid();
516  return base::kNullProcessId;
517}
518
519int PluginModule::GetPluginChildId() {
520  if (host_dispatcher_wrapper_)
521    return host_dispatcher_wrapper_->plugin_child_id();
522  return 0;
523}
524
525// static
526const PPB_Core* PluginModule::GetCore() { return &core_interface; }
527
528// static
529bool PluginModule::SupportsInterface(const char* name) {
530  return !!InternalGetInterface(name);
531}
532
533PepperPluginInstanceImpl* PluginModule::CreateInstance(
534    RenderFrameImpl* render_frame,
535    blink::WebPluginContainer* container,
536    const GURL& plugin_url) {
537  PepperPluginInstanceImpl* instance = PepperPluginInstanceImpl::Create(
538      render_frame, this, container, plugin_url);
539  if (!instance) {
540    LOG(WARNING) << "Plugin doesn't support instance interface, failing.";
541    return NULL;
542  }
543  if (host_dispatcher_wrapper_)
544    host_dispatcher_wrapper_->AddInstance(instance->pp_instance());
545  return instance;
546}
547
548PepperPluginInstanceImpl* PluginModule::GetSomeInstance() const {
549  // This will generally crash later if there is not actually any instance to
550  // return, so we force a crash now to make bugs easier to track down.
551  CHECK(!instances_.empty());
552  return *instances_.begin();
553}
554
555const void* PluginModule::GetPluginInterface(const char* name) const {
556  if (host_dispatcher_wrapper_)
557    return host_dispatcher_wrapper_->GetProxiedInterface(name);
558
559  // In-process plugins.
560  if (!entry_points_.get_interface)
561    return NULL;
562  return entry_points_.get_interface(name);
563}
564
565void PluginModule::InstanceCreated(PepperPluginInstanceImpl* instance) {
566  instances_.insert(instance);
567}
568
569void PluginModule::InstanceDeleted(PepperPluginInstanceImpl* instance) {
570  if (host_dispatcher_wrapper_)
571    host_dispatcher_wrapper_->RemoveInstance(instance->pp_instance());
572  instances_.erase(instance);
573}
574
575scoped_refptr<ppapi::CallbackTracker> PluginModule::GetCallbackTracker() {
576  return callback_tracker_;
577}
578
579void PluginModule::PluginCrashed() {
580  DCHECK(!is_crashed_);  // Should only get one notification.
581  is_crashed_ = true;
582
583  // Notify all instances that they crashed.
584  for (PluginInstanceSet::iterator i = instances_.begin();
585       i != instances_.end();
586       ++i)
587    (*i)->InstanceCrashed();
588
589  PepperPluginRegistry::GetInstance()->PluginModuleDead(this);
590}
591
592void PluginModule::SetReserveInstanceIDCallback(
593    PP_Bool (*reserve)(PP_Module, PP_Instance)) {
594  DCHECK(!reserve_instance_id_) << "Only expect one set.";
595  reserve_instance_id_ = reserve;
596}
597
598bool PluginModule::ReserveInstanceID(PP_Instance instance) {
599  if (reserve_instance_id_)
600    return PPBoolToBool(reserve_instance_id_(pp_module_, instance));
601  return true;  // Instance ID is usable.
602}
603
604void PluginModule::SetBroker(PepperBroker* broker) {
605  DCHECK(!broker_ || !broker);
606  broker_ = broker;
607}
608
609PepperBroker* PluginModule::GetBroker() { return broker_; }
610
611RendererPpapiHostImpl* PluginModule::CreateOutOfProcessModule(
612    RenderFrameImpl* render_frame,
613    const base::FilePath& path,
614    ppapi::PpapiPermissions permissions,
615    const IPC::ChannelHandle& channel_handle,
616    base::ProcessId peer_pid,
617    int plugin_child_id,
618    bool is_external) {
619  scoped_refptr<PepperHungPluginFilter> hung_filter(new PepperHungPluginFilter(
620      path, render_frame->GetRoutingID(), plugin_child_id));
621  scoped_ptr<HostDispatcherWrapper> dispatcher(new HostDispatcherWrapper(
622      this, peer_pid, plugin_child_id, permissions, is_external));
623  if (!dispatcher->Init(
624          channel_handle,
625          &GetInterface,
626          ppapi::Preferences(render_frame->render_view()->webkit_preferences()),
627          hung_filter.get()))
628    return NULL;
629
630  RendererPpapiHostImpl* host_impl =
631      RendererPpapiHostImpl::CreateOnModuleForOutOfProcess(
632          this, dispatcher->dispatcher(), permissions);
633  render_frame->PepperPluginCreated(host_impl);
634
635  InitAsProxied(dispatcher.release());
636  return host_impl;
637}
638
639// static
640void PluginModule::ResetHostGlobalsForTest() {
641  delete host_globals;
642  host_globals = NULL;
643}
644
645bool PluginModule::InitializeModule(
646    const PepperPluginInfo::EntryPoints& entry_points) {
647  DCHECK(!host_dispatcher_wrapper_.get()) << "Don't call for proxied modules.";
648  DCHECK(entry_points.initialize_module != NULL);
649  int retval = entry_points.initialize_module(pp_module(), &GetInterface);
650  if (retval != 0) {
651#if !defined(DISABLE_NACL)
652    LOG(WARNING) << "PPP_InitializeModule returned failure " << retval;
653#endif  // !defined(DISABLE_NACL)
654    return false;
655  }
656  return true;
657}
658
659scoped_refptr<PluginModule> PluginModule::Create(
660    RenderFrameImpl* render_frame,
661    const WebPluginInfo& webplugin_info,
662    bool* pepper_plugin_was_registered) {
663  *pepper_plugin_was_registered = true;
664
665  // See if a module has already been loaded for this plugin.
666  base::FilePath path(webplugin_info.path);
667  scoped_refptr<PluginModule> module =
668      PepperPluginRegistry::GetInstance()->GetLiveModule(path);
669  if (module.get()) {
670    if (!module->renderer_ppapi_host()) {
671      // If the module exists and no embedder state was associated with it,
672      // then the module was one of the ones preloaded and is an in-process
673      // plugin. We need to associate our host state with it.
674      CreateHostForInProcessModule(render_frame, module.get(), webplugin_info);
675    }
676    return module;
677  }
678
679  // In-process plugins will have always been created up-front to avoid the
680  // sandbox restrictions. So getting here implies it doesn't exist or should
681  // be out of process.
682  const PepperPluginInfo* info =
683      PepperPluginRegistry::GetInstance()->GetInfoForPlugin(webplugin_info);
684  if (!info) {
685    *pepper_plugin_was_registered = false;
686    return scoped_refptr<PluginModule>();
687  } else if (!info->is_out_of_process) {
688    // In-process plugin not preloaded, it probably couldn't be initialized.
689    return scoped_refptr<PluginModule>();
690  }
691
692  // Out of process: have the browser start the plugin process for us.
693  IPC::ChannelHandle channel_handle;
694  base::ProcessId peer_pid;
695  int plugin_child_id = 0;
696  render_frame->Send(new ViewHostMsg_OpenChannelToPepperPlugin(
697      path, &channel_handle, &peer_pid, &plugin_child_id));
698  if (channel_handle.name.empty()) {
699    // Couldn't be initialized.
700    return scoped_refptr<PluginModule>();
701  }
702
703  ppapi::PpapiPermissions permissions(info->permissions);
704
705  // AddLiveModule must be called before any early returns since the
706  // module's destructor will remove itself.
707  module = new PluginModule(info->name, path, permissions);
708  PepperPluginRegistry::GetInstance()->AddLiveModule(path, module.get());
709
710  if (!module->CreateOutOfProcessModule(render_frame,
711                                        path,
712                                        permissions,
713                                        channel_handle,
714                                        peer_pid,
715                                        plugin_child_id,
716                                        false))  // is_external = false
717    return scoped_refptr<PluginModule>();
718
719  return module;
720}
721
722}  // namespace content
723