ppapi/proxy/ppb_core_proxy.cc

   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 "ppapi/proxy/ppb_core_proxy.h"
   6
   7 #include <stdlib.h>  // For malloc
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/time/time.h"
  12 #include "base/trace_event/trace_event.h"
  13 #include "ppapi/c/pp_completion_callback.h"
  14 #include "ppapi/c/pp_resource.h"
  15 #include "ppapi/c/ppb_core.h"
  16 #include "ppapi/proxy/plugin_dispatcher.h"
  17 #include "ppapi/proxy/plugin_resource_tracker.h"
  18 #include "ppapi/proxy/ppapi_messages.h"
  19 #include "ppapi/shared_impl/ppapi_globals.h"
  20 #include "ppapi/shared_impl/proxy_lock.h"
  21 #include "ppapi/shared_impl/time_conversion.h"
  22
  23 namespace ppapi {
  24 namespace proxy {
  25
  26 namespace {
  27
  28 void AddRefResource(PP_Resource resource) {
  29   ppapi::ProxyAutoLock lock;
  30   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(resource);
  31 }
  32
  33 void ReleaseResource(PP_Resource resource) {
  34   ppapi::ProxyAutoLock lock;
  35   PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(resource);
  36 }
  37
  38 double GetTime() {
  39   return TimeToPPTime(base::Time::Now());
  40 }
  41
  42 double GetTimeTicks() {
  43   return TimeTicksToPPTimeTicks(base::TimeTicks::Now());
  44 }
  45
  46 void CallbackWrapper(PP_CompletionCallback callback, int32_t result) {
  47   TRACE_EVENT2("ppapi proxy", "CallOnMainThread callback",
  48                "Func", reinterpret_cast<void*>(callback.func),
  49                "UserData", callback.user_data);
  50   CallWhileUnlocked(PP_RunCompletionCallback, &callback, result);
  51 }
  52
  53 void CallOnMainThread(int delay_in_ms,
  54                       PP_CompletionCallback callback,
  55                       int32_t result) {
  56   DCHECK(callback.func);
  57 #if defined(OS_NACL)
  58   // Some NaCl apps pass a negative delay, so we just sanitize to 0, to run as
  59   // soon as possible. MessageLoop checks that the delay is non-negative.
  60   if (delay_in_ms < 0)
  61     delay_in_ms = 0;
  62 #endif
  63   if (!callback.func)
  64     return;
  65   ProxyAutoLock lock;
  66
  67   // If the plugin attempts to call CallOnMainThread from a background thread
  68   // at shutdown, it's possible that the PpapiGlobals object or the main loop
  69   // has been destroyed.
  70   if (!PpapiGlobals::Get() || !PpapiGlobals::Get()->GetMainThreadMessageLoop())
  71     return;
  72
  73   PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostDelayedTask(
  74       FROM_HERE,
  75       RunWhileLocked(base::Bind(&CallbackWrapper, callback, result)),
  76       base::TimeDelta::FromMilliseconds(delay_in_ms));
  77 }
  78
  79 PP_Bool IsMainThread() {
  80   return PP_FromBool(PpapiGlobals::Get()->
  81       GetMainThreadMessageLoop()->BelongsToCurrentThread());
  82 }
  83
  84 const PPB_Core core_interface = {
  85   &AddRefResource,
  86   &ReleaseResource,
  87   &GetTime,
  88   &GetTimeTicks,
  89   &CallOnMainThread,
  90   &IsMainThread
  91 };
  92
  93 }  // namespace
  94
  95 PPB_Core_Proxy::PPB_Core_Proxy(Dispatcher* dispatcher)
  96     : InterfaceProxy(dispatcher),
  97       ppb_core_impl_(NULL) {
  98   if (!dispatcher->IsPlugin()) {
  99     ppb_core_impl_ = static_cast<const PPB_Core*>(
 100         dispatcher->local_get_interface()(PPB_CORE_INTERFACE));
 101   }
 102 }
 103
 104 PPB_Core_Proxy::~PPB_Core_Proxy() {
 105 }
 106
 107 // static
 108 const PPB_Core* PPB_Core_Proxy::GetPPB_Core_Interface() {
 109   return &core_interface;
 110 }
 111
 112 bool PPB_Core_Proxy::OnMessageReceived(const IPC::Message& msg) {
 113 #if defined(OS_NACL)
 114   return false;
 115 #else
 116   bool handled = true;
 117   IPC_BEGIN_MESSAGE_MAP(PPB_Core_Proxy, msg)
 118     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBCore_AddRefResource,
 119                         OnMsgAddRefResource)
 120     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBCore_ReleaseResource,
 121                         OnMsgReleaseResource)
 122     IPC_MESSAGE_UNHANDLED(handled = false)
 123   IPC_END_MESSAGE_MAP()
 124   // TODO(brettw) handle bad messages!
 125   return handled;
 126 #endif
 127 }
 128
 129 #if !defined(OS_NACL)
 130 void PPB_Core_Proxy::OnMsgAddRefResource(const HostResource& resource) {
 131   ppb_core_impl_->AddRefResource(resource.host_resource());
 132 }
 133
 134 void PPB_Core_Proxy::OnMsgReleaseResource(const HostResource& resource) {
 135   ppb_core_impl_->ReleaseResource(resource.host_resource());
 136 }
 137 #endif  // !defined(OS_NACL)
 138
 139 }  // namespace proxy
 140 }  // namespace ppapi