Home | History | Annotate | Download | only in npapi 
      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_RENDERER_NPAPI_WEBPLUGIN_DELEGATE_PROXY_H_
      6 #define CONTENT_RENDERER_NPAPI_WEBPLUGIN_DELEGATE_PROXY_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/memory/ref_counted.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/memory/weak_ptr.h"
     14 #include "base/sequenced_task_runner_helpers.h"
     15 #include "content/child/npapi/webplugin_delegate.h"
     16 #include "content/public/common/webplugininfo.h"
     17 #include "ipc/ipc_listener.h"
     18 #include "ipc/ipc_message.h"
     19 #include "ipc/ipc_sender.h"
     20 #include "ui/gfx/native_widget_types.h"
     21 #include "ui/gfx/rect.h"
     22 #include "ui/surface/transport_dib.h"
     23 #include "url/gurl.h"
     24 
     25 #if defined(OS_MACOSX)
     26 #include "base/containers/hash_tables.h"
     27 #include "base/memory/linked_ptr.h"
     28 #endif
     29 
     30 struct NPObject;
     31 struct PluginHostMsg_URLRequest_Params;
     32 class SkBitmap;
     33 
     34 namespace base {
     35 class WaitableEvent;
     36 }
     37 
     38 namespace content {
     39 class NPObjectStub;
     40 class PluginChannelHost;
     41 class RenderFrameImpl;
     42 class RenderViewImpl;
     43 class WebPluginImpl;
     44 
     45 // An implementation of WebPluginDelegate that proxies all calls to
     46 // the plugin process.
     47 class WebPluginDelegateProxy
     48     : public WebPluginDelegate,
     49       public IPC::Listener,
     50       public IPC::Sender,
     51       public base::SupportsWeakPtr<WebPluginDelegateProxy> {
     52  public:
     53   WebPluginDelegateProxy(WebPluginImpl* plugin,
     54                          const std::string& mime_type,
     55                          const base::WeakPtr<RenderViewImpl>& render_view,
     56                          RenderFrameImpl* render_frame);
     57 
     58   // WebPluginDelegate implementation:
     59   virtual void PluginDestroyed() OVERRIDE;
     60   virtual bool Initialize(const GURL& url,
     61                           const std::vector<std::string>& arg_names,
     62                           const std::vector<std::string>& arg_values,
     63                           bool load_manually) OVERRIDE;
     64   virtual void UpdateGeometry(const gfx::Rect& window_rect,
     65                               const gfx::Rect& clip_rect) OVERRIDE;
     66   virtual void Paint(SkCanvas* canvas, const gfx::Rect& rect) OVERRIDE;
     67   virtual NPObject* GetPluginScriptableObject() OVERRIDE;
     68   virtual struct _NPP* GetPluginNPP() OVERRIDE;
     69   virtual bool GetFormValue(base::string16* value) OVERRIDE;
     70   virtual void DidFinishLoadWithReason(const GURL& url, NPReason reason,
     71                                        int notify_id) OVERRIDE;
     72   virtual void SetFocus(bool focused) OVERRIDE;
     73   virtual bool HandleInputEvent(const blink::WebInputEvent& event,
     74                                 WebCursor::CursorInfo* cursor) OVERRIDE;
     75   virtual int GetProcessId() OVERRIDE;
     76 
     77   // Informs the plugin that its containing content view has gained or lost
     78   // first responder status.
     79   virtual void SetContentAreaFocus(bool has_focus);
     80 #if defined(OS_WIN)
     81   // Informs the plugin that plugin IME has updated its status.
     82   virtual void ImeCompositionUpdated(
     83       const base::string16& text,
     84       const std::vector<int>& clauses,
     85       const std::vector<int>& target,
     86       int cursor_position,
     87       int plugin_id);
     88   // Informs the plugin that plugin IME has completed.
     89   // If |text| is empty, composition was cancelled.
     90   virtual void ImeCompositionCompleted(const base::string16& text,
     91                                        int plugin_id);
     92 #endif
     93 #if defined(OS_MACOSX)
     94   // Informs the plugin that its enclosing window has gained or lost focus.
     95   virtual void SetWindowFocus(bool window_has_focus);
     96   // Informs the plugin that its container (window/tab) has changed visibility.
     97   virtual void SetContainerVisibility(bool is_visible);
     98   // Informs the plugin that its enclosing window's frame has changed.
     99   virtual void WindowFrameChanged(gfx::Rect window_frame, gfx::Rect view_frame);
    100   // Informs the plugin that plugin IME has completed.
    101   // If |text| is empty, composition was cancelled.
    102   virtual void ImeCompositionCompleted(const base::string16& text,
    103                                        int plugin_id);
    104 #endif
    105 
    106   // IPC::Listener implementation:
    107   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
    108   virtual void OnChannelError() OVERRIDE;
    109 
    110   // IPC::Sender implementation:
    111   virtual bool Send(IPC::Message* msg) OVERRIDE;
    112 
    113   virtual void SendJavaScriptStream(const GURL& url,
    114                                     const std::string& result,
    115                                     bool success,
    116                                     int notify_id) OVERRIDE;
    117 
    118   virtual void DidReceiveManualResponse(const GURL& url,
    119                                         const std::string& mime_type,
    120                                         const std::string& headers,
    121                                         uint32 expected_length,
    122                                         uint32 last_modified) OVERRIDE;
    123   virtual void DidReceiveManualData(const char* buffer, int length) OVERRIDE;
    124   virtual void DidFinishManualLoading() OVERRIDE;
    125   virtual void DidManualLoadFail() OVERRIDE;
    126   virtual WebPluginResourceClient* CreateResourceClient(
    127       unsigned long resource_id, const GURL& url, int notify_id) OVERRIDE;
    128   virtual WebPluginResourceClient* CreateSeekableResourceClient(
    129       unsigned long resource_id, int range_request_id) OVERRIDE;
    130   virtual void FetchURL(unsigned long resource_id,
    131                         int notify_id,
    132                         const GURL& url,
    133                         const GURL& first_party_for_cookies,
    134                         const std::string& method,
    135                         const char* buf,
    136                         unsigned int len,
    137                         const GURL& referrer,
    138                         bool notify_redirects,
    139                         bool is_plugin_src_load,
    140                         int origin_pid,
    141                         int render_frame_id,
    142                         int render_view_id) OVERRIDE;
    143 
    144   gfx::PluginWindowHandle GetPluginWindowHandle();
    145 
    146  protected:
    147   friend class base::DeleteHelper<WebPluginDelegateProxy>;
    148   virtual ~WebPluginDelegateProxy();
    149 
    150  private:
    151   struct SharedBitmap {
    152     SharedBitmap();
    153     ~SharedBitmap();
    154 
    155     scoped_ptr<TransportDIB> dib;
    156     scoped_ptr<SkCanvas> canvas;
    157   };
    158 
    159   // Message handlers for messages that proxy WebPlugin methods, which
    160   // we translate into calls to the real WebPlugin.
    161   void OnSetWindow(gfx::PluginWindowHandle window);
    162   void OnCompleteURL(const std::string& url_in, std::string* url_out,
    163                      bool* result);
    164   void OnHandleURLRequest(const PluginHostMsg_URLRequest_Params& params);
    165   void OnCancelResource(int id);
    166   void OnInvalidateRect(const gfx::Rect& rect);
    167   void OnGetWindowScriptNPObject(int route_id, bool* success);
    168   void OnResolveProxy(const GURL& url, bool* result, std::string* proxy_list);
    169   void OnGetPluginElement(int route_id, bool* success);
    170   void OnSetCookie(const GURL& url,
    171                    const GURL& first_party_for_cookies,
    172                    const std::string& cookie);
    173   void OnGetCookies(const GURL& url, const GURL& first_party_for_cookies,
    174                     std::string* cookies);
    175   void OnCancelDocumentLoad();
    176   void OnInitiateHTTPRangeRequest(const std::string& url,
    177                                   const std::string& range_info,
    178                                   int range_request_id);
    179   void OnDidStartLoading();
    180   void OnDidStopLoading();
    181   void OnDeferResourceLoading(unsigned long resource_id, bool defer);
    182   void OnURLRedirectResponse(bool allow, int resource_id);
    183   void OnCheckIfRunInsecureContent(const GURL& url, bool* result);
    184 #if defined(OS_MACOSX)
    185   void OnFocusChanged(bool focused);
    186   void OnStartIme();
    187   // Accelerated (Core Animation) plugin implementation.
    188   void OnAcceleratedPluginEnabledRendering();
    189   void OnAcceleratedPluginAllocatedIOSurface(int32 width,
    190                                              int32 height,
    191                                              uint32 surface_id);
    192   void OnAcceleratedPluginSwappedIOSurface();
    193 #endif
    194 #if defined(OS_WIN)
    195   void OnSetWindowlessData(HANDLE modal_loop_pump_messages_event,
    196                            gfx::NativeViewId dummy_activation_window);
    197   void OnNotifyIMEStatus(const int input_mode, const gfx::Rect& caret_rect);
    198 #endif
    199   // Helper function that sends the UpdateGeometry message.
    200   void SendUpdateGeometry(bool bitmaps_changed);
    201 
    202   // Copies the given rectangle from the back-buffer transport_stores_ bitmap to
    203   // the front-buffer transport_stores_ bitmap.
    204   void CopyFromBackBufferToFrontBuffer(const gfx::Rect& rect);
    205 
    206   // Updates the front-buffer with the given rectangle from the back-buffer,
    207   // either by copying the rectangle or flipping the buffers.
    208   void UpdateFrontBuffer(const gfx::Rect& rect, bool allow_buffer_flipping);
    209 
    210   // Clears the shared memory section and canvases used for windowless plugins.
    211   void ResetWindowlessBitmaps();
    212 
    213   int front_buffer_index() const {
    214     return front_buffer_index_;
    215   }
    216 
    217   int back_buffer_index() const {
    218     return 1 - front_buffer_index_;
    219   }
    220 
    221   SkCanvas* front_buffer_canvas() const {
    222     return transport_stores_[front_buffer_index()].canvas.get();
    223   }
    224 
    225   SkCanvas* back_buffer_canvas() const {
    226     return transport_stores_[back_buffer_index()].canvas.get();
    227   }
    228 
    229   TransportDIB* front_buffer_dib() const {
    230     return transport_stores_[front_buffer_index()].dib.get();
    231   }
    232 
    233   TransportDIB* back_buffer_dib() const {
    234     return transport_stores_[back_buffer_index()].dib.get();
    235   }
    236 
    237 #if !defined(OS_WIN)
    238   // Creates a process-local memory section and canvas. PlatformCanvas on
    239   // Windows only works with a DIB, not arbitrary memory.
    240   bool CreateLocalBitmap(std::vector<uint8>* memory,
    241                          scoped_ptr<SkCanvas>* canvas);
    242 #endif
    243 
    244   // Creates a shared memory section and canvas.
    245   bool CreateSharedBitmap(scoped_ptr<TransportDIB>* memory,
    246                           scoped_ptr<SkCanvas>* canvas);
    247 
    248   // Called for cleanup during plugin destruction. Normally right before the
    249   // plugin window gets destroyed, or when the plugin has crashed (at which
    250   // point the window has already been destroyed).
    251   void WillDestroyWindow();
    252 
    253 #if defined(OS_WIN)
    254   // Returns true if we should update the plugin geometry synchronously.
    255   bool UseSynchronousGeometryUpdates();
    256 #endif
    257 
    258   base::WeakPtr<RenderViewImpl> render_view_;
    259   RenderFrameImpl* render_frame_;
    260   WebPluginImpl* plugin_;
    261   bool uses_shared_bitmaps_;
    262 #if defined(OS_MACOSX)
    263   bool uses_compositor_;
    264 #elif defined(OS_WIN)
    265   // Used for windowless plugins so that keyboard activation works.
    266   gfx::NativeViewId dummy_activation_window_;
    267 #endif
    268   gfx::PluginWindowHandle window_;
    269   scoped_refptr<PluginChannelHost> channel_host_;
    270   std::string mime_type_;
    271   int instance_id_;
    272   WebPluginInfo info_;
    273 
    274   gfx::Rect plugin_rect_;
    275   gfx::Rect clip_rect_;
    276 
    277   NPObject* npobject_;
    278 
    279   // Dummy NPP used to uniquely identify this plugin.
    280   scoped_ptr<NPP_t> npp_;
    281 
    282   // Event passed in by the plugin process and is used to decide if messages
    283   // need to be pumped in the NPP_HandleEvent sync call.
    284   scoped_ptr<base::WaitableEvent> modal_loop_pump_messages_event_;
    285 
    286   // Bitmap for crashed plugin
    287   SkBitmap* sad_plugin_;
    288 
    289   // True if we got an invalidate from the plugin and are waiting for a paint.
    290   bool invalidate_pending_;
    291 
    292   // If the plugin is transparent or not.
    293   bool transparent_;
    294 
    295   // The index in the transport_stores_ array of the current front buffer
    296   // (i.e., the buffer to display).
    297   int front_buffer_index_;
    298   SharedBitmap transport_stores_[2];
    299   // This lets us know the total portion of the transport store that has been
    300   // painted since the buffers were created.
    301   gfx::Rect transport_store_painted_;
    302   // This is a bounding box on the portion of the front-buffer that was painted
    303   // on the last buffer flip and which has not yet been re-painted in the
    304   // back-buffer.
    305   gfx::Rect front_buffer_diff_;
    306 
    307   // The url of the main frame hosting the plugin.
    308   GURL page_url_;
    309 
    310   DISALLOW_COPY_AND_ASSIGN(WebPluginDelegateProxy);
    311 };
    312 
    313 }  // namespace content
    314 
    315 #endif  // CONTENT_RENDERER_NPAPI_WEBPLUGIN_DELEGATE_PROXY_H_
    316