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