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