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