ppapi/proxy/enter_proxy.h

   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 #ifndef PPAPI_PROXY_ENTER_PROXY_H_
   6 #define PPAPI_PROXY_ENTER_PROXY_H_
   7
   8 #include "base/logging.h"
   9 #include "ppapi/cpp/completion_callback.h"
  10 #include "ppapi/proxy/host_dispatcher.h"
  11 #include "ppapi/proxy/plugin_dispatcher.h"
  12 #include "ppapi/proxy/plugin_globals.h"
  13 #include "ppapi/proxy/plugin_resource_tracker.h"
  14 #include "ppapi/thunk/enter.h"
  15
  16 namespace ppapi {
  17
  18 namespace proxy {
  19
  20 // Wrapper around EnterResourceNoLock that takes a host resource. This is used
  21 // when handling messages in the plugin from the host and we need to convert to
  22 // an object in the plugin side corresponding to that.
  23 //
  24 // This never locks since we assume the host Resource is coming from IPC, and
  25 // never logs errors since we assume the host is doing reasonable things.
  26 template<typename ResourceT>
  27 class EnterPluginFromHostResource
  28     : public thunk::EnterResourceNoLock<ResourceT> {
  29  public:
  30   explicit EnterPluginFromHostResource(const HostResource& host_resource)
  31       : thunk::EnterResourceNoLock<ResourceT>(
  32             PluginGlobals::Get()->plugin_resource_tracker()->
  33                 PluginResourceForHostResource(host_resource),
  34             false) {
  35     // Validate that we're in the plugin rather than the host. Otherwise this
  36     // object will do the wrong thing. In the plugin, the instance should have
  37     // a corresponding plugin dispatcher (assuming the resource is valid).
  38     DCHECK(this->failed() ||
  39            PluginDispatcher::GetForInstance(host_resource.instance()));
  40   }
  41 };
  42
  43 template<typename ResourceT>
  44 class EnterHostFromHostResource
  45     : public thunk::EnterResourceNoLock<ResourceT> {
  46  public:
  47   explicit EnterHostFromHostResource(const HostResource& host_resource)
  48       : thunk::EnterResourceNoLock<ResourceT>(host_resource.host_resource(),
  49                                               false) {
  50     // Validate that we're in the host rather than the plugin. Otherwise this
  51     // object will do the wrong thing. In the host, the instance should have
  52     // a corresponding host disptacher (assuming the resource is valid).
  53     DCHECK(this->failed() ||
  54            HostDispatcher::GetForInstance(host_resource.instance()));
  55   }
  56
  57   EnterHostFromHostResource(const HostResource& host_resource,
  58                             const pp::CompletionCallback& callback)
  59       : thunk::EnterResourceNoLock<ResourceT>(host_resource.host_resource(),
  60                                               callback.pp_completion_callback(),
  61                                               false) {
  62     // Validate that we're in the host rather than the plugin. Otherwise this
  63     // object will do the wrong thing. In the host, the instance should have
  64     // a corresponding host disptacher (assuming the resource is valid).
  65     DCHECK(this->failed() ||
  66            HostDispatcher::GetForInstance(host_resource.instance()));
  67   }
  68 };
  69
  70 // Enters a resource and forces a completion callback to be issued.
  71 //
  72 // This is used when implementing the host (renderer) side of a resource
  73 // function that issues a completion callback. In all cases, we need to issue
  74 // the callback to avoid hanging the plugin.
  75 //
  76 // This class automatically constructs a callback with the given factory
  77 // calling the given method. The method will generally be the one that sends
  78 // the message to trigger the completion callback in the plugin process.
  79 //
  80 // It will automatically issue the callback with PP_ERROR_NOINTERFACE if the
  81 // host resource is invalid (i.e. failed() is set). In all other cases you
  82 // should call SetResult(), which will issue the callback immediately if the
  83 // result value isn't PP_OK_COMPLETIONPENDING. In the "completion pending"
  84 // case, it's assumed the function the proxy is calling will take responsibility
  85 // of executing the callback (returned by callback()).
  86 //
  87 // Example:
  88 //   EnterHostFromHostResourceForceCallback<PPB_Foo_API> enter(
  89 //       resource, callback_factory_, &MyClass::SendResult, resource);
  90 //   if (enter.failed())
  91 //     return;  // SendResult automatically called with PP_ERROR_BADRESOURCE.
  92 //   enter.SetResult(enter.object()->DoFoo(enter.callback()));
  93 //
  94 // Where DoFoo's signature looks like this:
  95 //   int32_t DoFoo(PP_CompletionCallback callback);
  96 // And SendResult's implementation looks like this:
  97 //   void MyClass::SendResult(int32_t result, const HostResource& res) {
  98 //     Send(new FooMsg_FooComplete(..., result, res));
  99 //   }
 100 template<typename ResourceT>
 101 class EnterHostFromHostResourceForceCallback
 102     : public EnterHostFromHostResource<ResourceT> {
 103  public:
 104   EnterHostFromHostResourceForceCallback(
 105       const HostResource& host_resource,
 106       const pp::CompletionCallback& callback)
 107       : EnterHostFromHostResource<ResourceT>(host_resource, callback),
 108         needs_running_(true) {
 109   }
 110
 111   // For callbacks that take no parameters except the "int32_t result". Most
 112   // implementations will use the 1-extra-argument constructor below.
 113   template<class CallbackFactory, typename Method>
 114   EnterHostFromHostResourceForceCallback(
 115       const HostResource& host_resource,
 116       CallbackFactory& factory,
 117       Method method)
 118       : EnterHostFromHostResource<ResourceT>(host_resource,
 119             factory.NewOptionalCallback(method)),
 120         needs_running_(true) {
 121     if (this->failed())
 122       RunCallback(PP_ERROR_BADRESOURCE);
 123   }
 124
 125   // For callbacks that take an extra parameter as a closure.
 126   template<class CallbackFactory, typename Method, typename A>
 127   EnterHostFromHostResourceForceCallback(
 128       const HostResource& host_resource,
 129       CallbackFactory& factory,
 130       Method method,
 131       const A& a)
 132       : EnterHostFromHostResource<ResourceT>(host_resource,
 133             factory.NewOptionalCallback(method, a)),
 134         needs_running_(true) {
 135     if (this->failed())
 136       RunCallback(PP_ERROR_BADRESOURCE);
 137   }
 138
 139   // For callbacks that take two extra parameters as a closure.
 140   template<class CallbackFactory, typename Method, typename A, typename B>
 141   EnterHostFromHostResourceForceCallback(
 142       const HostResource& host_resource,
 143       CallbackFactory& factory,
 144       Method method,
 145       const A& a,
 146       const B& b)
 147       : EnterHostFromHostResource<ResourceT>(host_resource,
 148             factory.NewOptionalCallback(method, a, b)),
 149         needs_running_(true) {
 150     if (this->failed())
 151       RunCallback(PP_ERROR_BADRESOURCE);
 152   }
 153
 154   // For callbacks that take three extra parameters as a closure.
 155   template<class CallbackFactory, typename Method, typename A, typename B,
 156            typename C>
 157   EnterHostFromHostResourceForceCallback(
 158       const HostResource& host_resource,
 159       CallbackFactory& factory,
 160       Method method,
 161       const A& a,
 162       const B& b,
 163       const C& c)
 164       : EnterHostFromHostResource<ResourceT>(host_resource,
 165             factory.NewOptionalCallback(method, a, b, c)),
 166         needs_running_(true) {
 167     if (this->failed())
 168       RunCallback(PP_ERROR_BADRESOURCE);
 169   }
 170
 171   ~EnterHostFromHostResourceForceCallback() {
 172     if (needs_running_) {
 173       NOTREACHED() << "Should always call SetResult except in the "
 174                       "initialization failed case.";
 175       RunCallback(PP_ERROR_FAILED);
 176     }
 177   }
 178
 179   void SetResult(int32_t result) {
 180     DCHECK(needs_running_) << "Don't call SetResult when there already is one.";
 181     if (result != PP_OK_COMPLETIONPENDING)
 182       RunCallback(result);
 183     needs_running_ = false;
 184     // Either we already ran the callback, or it will be run asynchronously. We
 185     // clear the callback so it isn't accidentally run again (and because
 186     // EnterBase checks that the callback has been cleared).
 187     this->ClearCallback();
 188   }
 189
 190  private:
 191   void RunCallback(int32_t result) {
 192     DCHECK(needs_running_);
 193     needs_running_ = false;
 194     this->callback()->Run(result);
 195     this->ClearCallback();
 196   }
 197
 198   bool needs_running_;
 199 };
 200
 201 }  // namespace proxy
 202 }  // namespace ppapi
 203
 204 #endif  // PPAPI_PROXY_ENTER_PROXY_H_