ppapi/shared_impl/resource.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_SHARED_IMPL_RESOURCE_H_
   6 #define PPAPI_SHARED_IMPL_RESOURCE_H_
   7
   8 #include <stddef.h>  // For NULL.
   9
  10 #include <string>
  11
  12 #include "base/basictypes.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "ppapi/c/pp_instance.h"
  15 #include "ppapi/c/pp_resource.h"
  16 #include "ppapi/c/ppb_console.h"
  17 #include "ppapi/shared_impl/host_resource.h"
  18
  19 // All resource types should be added here. This implements our hand-rolled
  20 // RTTI system since we don't compile with "real" RTTI.
  21 #define FOR_ALL_PPAPI_RESOURCE_APIS(F)  \
  22   F(PPB_Audio_API)                      \
  23   F(PPB_AudioBuffer_API)                \
  24   F(PPB_AudioConfig_API)                \
  25   F(PPB_AudioInput_API)                 \
  26   F(PPB_AudioTrusted_API)               \
  27   F(PPB_Broker_API)                     \
  28   F(PPB_Broker_Instance_API)            \
  29   F(PPB_BrowserFont_Singleton_API)      \
  30   F(PPB_BrowserFont_Trusted_API)        \
  31   F(PPB_Buffer_API)                     \
  32   F(PPB_CameraCapabilities_API)         \
  33   F(PPB_CameraDevice_API)               \
  34   F(PPB_Compositor_API)                 \
  35   F(PPB_CompositorLayer_API)            \
  36   F(PPB_DeviceRef_API)                  \
  37   F(PPB_Ext_CrxFileSystem_Private_API)  \
  38   F(PPB_FileChooser_API)                \
  39   F(PPB_FileIO_API)                     \
  40   F(PPB_FileRef_API)                    \
  41   F(PPB_FileSystem_API)                 \
  42   F(PPB_Find_API)                       \
  43   F(PPB_Flash_Clipboard_API)            \
  44   F(PPB_Flash_DRM_API)                  \
  45   F(PPB_Flash_File_API)                 \
  46   F(PPB_Flash_FontFile_API)             \
  47   F(PPB_Flash_Fullscreen_API)           \
  48   F(PPB_Flash_Functions_API)            \
  49   F(PPB_Flash_Menu_API)                 \
  50   F(PPB_Flash_MessageLoop_API)          \
  51   F(PPB_Gamepad_API)                    \
  52   F(PPB_Graphics2D_API)                 \
  53   F(PPB_Graphics3D_API)                 \
  54   F(PPB_HostResolver_API)               \
  55   F(PPB_HostResolver_Private_API)       \
  56   F(PPB_ImageData_API)                  \
  57   F(PPB_InputEvent_API)                 \
  58   F(PPB_IsolatedFileSystem_Private_API) \
  59   F(PPB_MediaStreamAudioTrack_API)      \
  60   F(PPB_MediaStreamVideoTrack_API)      \
  61   F(PPB_MessageLoop_API)                \
  62   F(PPB_NetAddress_API)                 \
  63   F(PPB_NetworkList_API)                \
  64   F(PPB_NetworkMonitor_API)             \
  65   F(PPB_NetworkProxy_API)               \
  66   F(PPB_OutputProtection_API)           \
  67   F(PPB_PDF_API)                        \
  68   F(PPB_PlatformVerification_API)       \
  69   F(PPB_Printing_API)                   \
  70   F(PPB_Scrollbar_API)                  \
  71   F(PPB_TrueTypeFont_API)               \
  72   F(PPB_TrueTypeFont_Singleton_API)     \
  73   F(PPB_TCPServerSocket_Private_API)    \
  74   F(PPB_TCPSocket_API)                  \
  75   F(PPB_TCPSocket_Private_API)          \
  76   F(PPB_UDPSocket_API)                  \
  77   F(PPB_UDPSocket_Private_API)          \
  78   F(PPB_UMA_Singleton_API)              \
  79   F(PPB_URLLoader_API)                  \
  80   F(PPB_URLRequestInfo_API)             \
  81   F(PPB_URLResponseInfo_API)            \
  82   F(PPB_VideoCapture_API)               \
  83   F(PPB_VideoDecoder_API)               \
  84   F(PPB_VideoDecoder_Dev_API)           \
  85   F(PPB_VideoDestination_Private_API)   \
  86   F(PPB_VideoEncoder_API)               \
  87   F(PPB_VideoFrame_API)                 \
  88   F(PPB_VideoLayer_API)                 \
  89   F(PPB_VideoSource_Private_API)        \
  90   F(PPB_View_API)                       \
  91   F(PPB_WebSocket_API)                  \
  92   F(PPB_Widget_API)                     \
  93   F(PPB_X509Certificate_Private_API)
  94
  95 namespace IPC {
  96 class Message;
  97 }
  98
  99 namespace ppapi {
 100
 101 // Normally we shouldn't reply on proxy here, but this is to support
 102 // OnReplyReceived. See that comment.
 103 namespace proxy {
 104 class ResourceMessageReplyParams;
 105 }
 106
 107 // Forward declare all the resource APIs.
 108 namespace thunk {
 109 #define DECLARE_RESOURCE_CLASS(RESOURCE) class RESOURCE;
 110 FOR_ALL_PPAPI_RESOURCE_APIS(DECLARE_RESOURCE_CLASS)
 111 #undef DECLARE_RESOURCE_CLASS
 112 }  // namespace thunk
 113
 114 // Resources have slightly different registration behaviors when the're an
 115 // in-process ("impl") resource in the host (renderer) process, or when they're
 116 // a proxied resource in the plugin process. This enum differentiates those
 117 // cases.
 118 enum ResourceObjectType { OBJECT_IS_IMPL, OBJECT_IS_PROXY };
 119
 120 class PPAPI_SHARED_EXPORT Resource : public base::RefCounted<Resource> {
 121  public:
 122   // Constructor for impl and non-proxied, instance-only objects.
 123   //
 124   // For constructing "impl" (non-proxied) objects, this just takes the
 125   // associated instance, and generates a new resource ID. The host resource
 126   // will be the same as the newly-generated resource ID. For all objects in
 127   // the renderer (host) process, you'll use this constructor and call it with
 128   // OBJECT_IS_IMPL.
 129   //
 130   // For proxied objects, this will create an "instance-only" object which
 131   // lives only in the plugin and doesn't have a corresponding object in the
 132   // host. If you have a host resource ID, use the constructor below which
 133   // takes that HostResource value.
 134   Resource(ResourceObjectType type, PP_Instance instance);
 135
 136   // For constructing given a host resource.
 137   //
 138   // For OBJECT_IS_PROXY objects, this takes the resource generated in the host
 139   // side, stores it, and allocates a "local" resource ID for use in the
 140   // current process.
 141   //
 142   // For OBJECT_IS_IMPL, the host resource ID must be 0, since there should be
 143   // no host resource generated (impl objects should generate their own). The
 144   // reason for supporting this constructor at all for the IMPL case is that
 145   // some shared objects use a host resource for both modes to keep things the
 146   // same.
 147   Resource(ResourceObjectType type, const HostResource& host_resource);
 148
 149   // Constructor for untracked objects. These have no associated instance. Use
 150   // this with care, as the object is likely to persist for the lifetime of the
 151   // plugin module. This is appropriate in some rare cases, like the
 152   // PPB_MessageLoop resource for the main thread.
 153   struct Untracked {};
 154   explicit Resource(Untracked);
 155
 156   virtual ~Resource();
 157
 158   PP_Instance pp_instance() const { return host_resource_.instance(); }
 159
 160   // Returns the resource ID for this object in the current process without
 161   // adjusting the refcount. See also GetReference().
 162   PP_Resource pp_resource() const { return pp_resource_; }
 163
 164   // Returns the host resource which identifies the resource in the host side
 165   // of the process in the case of proxied objects. For in-process objects,
 166   // this just identifies the in-process resource ID & instance.
 167   const HostResource& host_resource() { return host_resource_; }
 168
 169   // Adds a ref on behalf of the plugin and returns the resource ID. This is
 170   // normally used when returning a resource to the plugin, where it's
 171   // expecting the returned resource to have ownership of a ref passed.
 172   // See also pp_resource() to avoid the AddRef.
 173   PP_Resource GetReference();
 174
 175   // Called by the resource tracker when the last reference from the plugin
 176   // was released. For a few types of resources, the resource could still
 177   // stay alive if there are other references held by the PPAPI implementation
 178   // (possibly for callbacks and things).
 179   //
 180   // Note that subclasses except PluginResource should override
 181   // LastPluginRefWasDeleted() to be notified.
 182   virtual void NotifyLastPluginRefWasDeleted();
 183
 184   // Called by the resource tracker when the instance is going away but the
 185   // object is still alive (this is not the common case, since it requires
 186   // something in the implementation to be keeping a ref that keeps the
 187   // resource alive.
 188   //
 189   // You will want to override this if your resource does some kind of
 190   // background processing (like maybe network loads) on behalf of the plugin
 191   // and you want to stop that when the plugin is deleted.
 192   //
 193   // Note that subclasses except PluginResource should override
 194   // InstanceWasDeleted() to be notified.
 195   virtual void NotifyInstanceWasDeleted();
 196
 197 // Dynamic casting for this object. Returns the pointer to the given type if
 198 // it's supported. Derived classes override the functions they support to
 199 // return the interface.
 200 #define DEFINE_TYPE_GETTER(RESOURCE) virtual thunk::RESOURCE* As##RESOURCE();
 201   FOR_ALL_PPAPI_RESOURCE_APIS(DEFINE_TYPE_GETTER)
 202 #undef DEFINE_TYPE_GETTER
 203
 204   // Template-based dynamic casting. See specializations below. This is
 205   // unimplemented for the default case. This way, for anything that's not a
 206   // resource (or if a developer forgets to add the resource to the list in
 207   // this file), the result is a linker error.
 208   template <typename T>
 209   T* GetAs();
 210
 211   // Called when a PpapiPluginMsg_ResourceReply reply is received for a
 212   // previous CallRenderer. The message is the nested reply message, which may
 213   // be an empty message (depending on what the host sends).
 214   //
 215   // The default implementation will assert (if you send a request, you should
 216   // override this function).
 217   //
 218   // (This function would make more conceptual sense on PluginResource but we
 219   // need to call this function from general code that doesn't know how to
 220   // distinguish the classes.)
 221   virtual void OnReplyReceived(const proxy::ResourceMessageReplyParams& params,
 222                                const IPC::Message& msg);
 223
 224  protected:
 225   // Logs a message to the console from this resource.
 226   void Log(PP_LogLevel level, const std::string& message);
 227
 228   // Removes the resource from the ResourceTracker's tables. This normally
 229   // happens as part of Resource destruction, but if a subclass destructor
 230   // has a risk of re-entering destruction via the ResourceTracker, it can
 231   // call this explicitly to get rid of the table entry before continuing
 232   // with the destruction. If the resource is not in the ResourceTracker's
 233   // tables, silently does nothing. See http://crbug.com/159429.
 234   void RemoveFromResourceTracker();
 235
 236   // Notifications for subclasses.
 237   virtual void LastPluginRefWasDeleted() {}
 238   virtual void InstanceWasDeleted() {}
 239
 240  private:
 241   // See the getters above.
 242   PP_Resource pp_resource_;
 243   HostResource host_resource_;
 244
 245   DISALLOW_IMPLICIT_CONSTRUCTORS(Resource);
 246 };
 247
 248 // Template-based dynamic casting. These specializations forward to the
 249 // AsXXX virtual functions to return whether the given type is supported.
 250 #define DEFINE_RESOURCE_CAST(RESOURCE)        \
 251   template <>                                 \
 252   inline thunk::RESOURCE* Resource::GetAs() { \
 253     return As##RESOURCE();                    \
 254   }
 255 FOR_ALL_PPAPI_RESOURCE_APIS(DEFINE_RESOURCE_CAST)
 256 #undef DEFINE_RESOURCE_CAST
 257
 258 }  // namespace ppapi
 259
 260 #endif  // PPAPI_SHARED_IMPL_RESOURCE_H_