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 CONTENT_PLUGIN_WEBPLUGIN_PROXY_H_ 6 #define CONTENT_PLUGIN_WEBPLUGIN_PROXY_H_ 7 8 #include <string> 9 10 #include "base/containers/hash_tables.h" 11 #include "base/memory/ref_counted.h" 12 #if defined(OS_MACOSX) 13 #include "base/mac/scoped_cftyperef.h" 14 #endif 15 #include "base/memory/scoped_handle.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "base/memory/shared_memory.h" 18 #include "base/memory/weak_ptr.h" 19 #include "base/timer/timer.h" 20 #include "content/child/npapi/webplugin.h" 21 #include "ipc/ipc_message.h" 22 #include "ipc/ipc_sender.h" 23 #include "skia/ext/refptr.h" 24 #include "third_party/skia/include/core/SkCanvas.h" 25 #include "url/gurl.h" 26 #if defined(USE_X11) 27 #include "ui/base/x/x11_util.h" 28 #endif 29 #include "ui/gl/gpu_preference.h" 30 #include "ui/surface/transport_dib.h" 31 32 struct PluginMsg_FetchURL_Params; 33 34 namespace content { 35 class PluginChannel; 36 class WebPluginDelegateImpl; 37 38 #if defined(OS_MACOSX) 39 class WebPluginAcceleratedSurfaceProxy; 40 #endif 41 42 // This is an implementation of WebPlugin that proxies all calls to the 43 // renderer. 44 class WebPluginProxy : public WebPlugin, 45 public IPC::Sender { 46 public: 47 // Creates a new proxy for WebPlugin, using the given sender to send the 48 // marshalled WebPlugin calls. 49 WebPluginProxy(PluginChannel* channel, 50 int route_id, 51 const GURL& page_url, 52 int host_render_view_routing_id); 53 virtual ~WebPluginProxy(); 54 set_delegate(WebPluginDelegateImpl * d)55 void set_delegate(WebPluginDelegateImpl* d) { delegate_ = d; } 56 57 // WebPlugin overrides 58 virtual void SetWindow(gfx::PluginWindowHandle window) OVERRIDE; 59 virtual void SetAcceptsInputEvents(bool accepts) OVERRIDE; 60 virtual void WillDestroyWindow(gfx::PluginWindowHandle window) OVERRIDE; 61 virtual void CancelResource(unsigned long id) OVERRIDE; 62 virtual void Invalidate() OVERRIDE; 63 virtual void InvalidateRect(const gfx::Rect& rect) OVERRIDE; 64 virtual NPObject* GetWindowScriptNPObject() OVERRIDE; 65 virtual NPObject* GetPluginElement() OVERRIDE; 66 virtual bool FindProxyForUrl(const GURL& url, 67 std::string* proxy_list) OVERRIDE; 68 virtual void SetCookie(const GURL& url, 69 const GURL& first_party_for_cookies, 70 const std::string& cookie) OVERRIDE; 71 virtual std::string GetCookies(const GURL& url, 72 const GURL& first_party_for_cookies) OVERRIDE; 73 virtual void HandleURLRequest(const char* url, 74 const char* method, 75 const char* target, 76 const char* buf, 77 unsigned int len, 78 int notify_id, 79 bool popups_allowed, 80 bool notify_redirects) OVERRIDE; 81 void UpdateGeometry(const gfx::Rect& window_rect, 82 const gfx::Rect& clip_rect, 83 const TransportDIB::Handle& windowless_buffer0, 84 const TransportDIB::Handle& windowless_buffer1, 85 int windowless_buffer_index); 86 virtual void CancelDocumentLoad() OVERRIDE; 87 virtual void InitiateHTTPRangeRequest( 88 const char* url, const char* range_info, int range_request_id) OVERRIDE; 89 virtual void DidStartLoading() OVERRIDE; 90 virtual void DidStopLoading() OVERRIDE; 91 virtual void SetDeferResourceLoading(unsigned long resource_id, 92 bool defer) OVERRIDE; 93 virtual bool IsOffTheRecord() OVERRIDE; 94 virtual void ResourceClientDeleted( 95 WebPluginResourceClient* resource_client) OVERRIDE; 96 virtual void URLRedirectResponse(bool allow, int resource_id) OVERRIDE; 97 virtual bool CheckIfRunInsecureContent(const GURL& url) OVERRIDE; 98 #if defined(OS_WIN) 99 void SetWindowlessData(HANDLE pump_messages_event, 100 gfx::NativeViewId dummy_activation_window); 101 #endif 102 #if defined(OS_MACOSX) 103 virtual void FocusChanged(bool focused) OVERRIDE; 104 virtual void StartIme() OVERRIDE; 105 virtual WebPluginAcceleratedSurface* 106 GetAcceleratedSurface(gfx::GpuPreference gpu_preference) OVERRIDE; 107 virtual void AcceleratedPluginEnabledRendering() OVERRIDE; 108 virtual void AcceleratedPluginAllocatedIOSurface(int32 width, 109 int32 height, 110 uint32 surface_id) OVERRIDE; 111 virtual void AcceleratedPluginSwappedIOSurface() OVERRIDE; 112 #endif 113 114 // IPC::Sender implementation. 115 virtual bool Send(IPC::Message* msg) OVERRIDE; 116 117 // class-specific methods 118 119 // Returns a WebPluginResourceClient object given its id, or NULL if no 120 // object with that id exists. 121 WebPluginResourceClient* GetResourceClient(int id); 122 123 // Returns the id of the renderer that contains this plugin. 124 int GetRendererId(); 125 126 // Returns the id of the associated render view. host_render_view_routing_id()127 int host_render_view_routing_id() const { 128 return host_render_view_routing_id_; 129 } 130 131 // For windowless plugins, paints the given rectangle into the local buffer. 132 void Paint(const gfx::Rect& rect); 133 134 // Callback from the renderer to let us know that a paint occurred. 135 void DidPaint(); 136 137 // Notification received on a plugin issued resource request creation. 138 void OnResourceCreated(int resource_id, WebPluginResourceClient* client); 139 140 #if defined(OS_WIN) && !defined(USE_AURA) 141 // Retrieves the IME status from a windowless plug-in and sends it to a 142 // renderer process. A renderer process will convert the coordinates from 143 // local to the window coordinates and send the converted coordinates to a 144 // browser process. 145 void UpdateIMEStatus(); 146 #endif 147 148 private: 149 class SharedTransportDIB : public base::RefCounted<SharedTransportDIB> { 150 public: 151 explicit SharedTransportDIB(TransportDIB* dib); dib()152 TransportDIB* dib() { return dib_.get(); } 153 private: 154 friend class base::RefCounted<SharedTransportDIB>; 155 ~SharedTransportDIB(); 156 157 scoped_ptr<TransportDIB> dib_; 158 }; 159 160 // Handler for sending over the paint event to the plugin. 161 void OnPaint(const gfx::Rect& damaged_rect); 162 163 #if defined(OS_WIN) 164 void CreateCanvasFromHandle(const TransportDIB::Handle& dib_handle, 165 const gfx::Rect& window_rect, 166 skia::RefPtr<SkCanvas>* canvas); 167 #elif defined(OS_MACOSX) 168 static void CreateDIBAndCGContextFromHandle( 169 const TransportDIB::Handle& dib_handle, 170 const gfx::Rect& window_rect, 171 scoped_ptr<TransportDIB>* dib_out, 172 base::ScopedCFTypeRef<CGContextRef>* cg_context_out); 173 #elif defined(USE_X11) 174 static void CreateDIBAndCanvasFromHandle( 175 const TransportDIB::Handle& dib_handle, 176 const gfx::Rect& window_rect, 177 scoped_refptr<SharedTransportDIB>* dib_out, 178 skia::RefPtr<SkCanvas>* canvas); 179 180 static void CreateShmPixmapFromDIB( 181 TransportDIB* dib, 182 const gfx::Rect& window_rect, 183 XID* pixmap_out); 184 #endif 185 186 // Updates the shared memory sections where windowless plugins paint. 187 void SetWindowlessBuffers(const TransportDIB::Handle& windowless_buffer0, 188 const TransportDIB::Handle& windowless_buffer1, 189 const gfx::Rect& window_rect); 190 191 #if defined(OS_MACOSX) windowless_context()192 CGContextRef windowless_context() const { 193 return windowless_contexts_[windowless_buffer_index_].get(); 194 } 195 #else windowless_canvas()196 skia::RefPtr<SkCanvas> windowless_canvas() const { 197 return windowless_canvases_[windowless_buffer_index_]; 198 } 199 200 #if defined(USE_X11) windowless_shm_pixmap()201 XID windowless_shm_pixmap() const { 202 return windowless_shm_pixmaps_[windowless_buffer_index_]; 203 } 204 #endif 205 206 #endif 207 208 typedef base::hash_map<int, WebPluginResourceClient*> ResourceClientMap; 209 ResourceClientMap resource_clients_; 210 211 scoped_refptr<PluginChannel> channel_; 212 int route_id_; 213 NPObject* window_npobject_; 214 NPObject* plugin_element_; 215 WebPluginDelegateImpl* delegate_; 216 gfx::Rect damaged_rect_; 217 bool waiting_for_paint_; 218 // The url of the main frame hosting the plugin. 219 GURL page_url_; 220 221 // Variables used for desynchronized windowless plugin painting. See note in 222 // webplugin_delegate_proxy.h for how this works. The two sets of windowless_* 223 // fields are for the front-buffer and back-buffer of a buffer flipping system 224 // and windowless_buffer_index_ identifies which set we are using as the 225 // back-buffer at any given time. 226 int windowless_buffer_index_; 227 #if defined(OS_MACOSX) 228 scoped_ptr<TransportDIB> windowless_dibs_[2]; 229 base::ScopedCFTypeRef<CGContextRef> windowless_contexts_[2]; 230 scoped_ptr<WebPluginAcceleratedSurfaceProxy> accelerated_surface_; 231 #else 232 skia::RefPtr<SkCanvas> windowless_canvases_[2]; 233 234 #if defined(USE_X11) 235 scoped_refptr<SharedTransportDIB> windowless_dibs_[2]; 236 // If we can use SHM pixmaps for windowless plugin painting or not. 237 bool use_shm_pixmap_; 238 // The SHM pixmaps for windowless plugin painting. 239 XID windowless_shm_pixmaps_[2]; 240 #endif 241 242 #endif 243 244 // Contains the routing id of the host render view. 245 int host_render_view_routing_id_; 246 247 base::WeakPtrFactory<WebPluginProxy> weak_factory_; 248 }; 249 250 } // namespace content 251 252 #endif // CONTENT_PLUGIN_WEBPLUGIN_PROXY_H_ 253