src/content/renderer/npapi/webplugin_impl.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 CONTENT_RENDERER_NPAPI_WEBPLUGIN_IMPL_H_
   6 #define CONTENT_RENDERER_NPAPI_WEBPLUGIN_IMPL_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/files/file_path.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "content/child/npapi/webplugin.h"
  17 #include "content/common/content_export.h"
  18 #include "content/common/webplugin_geometry.h"
  19 #include "third_party/WebKit/public/platform/WebRect.h"
  20 #include "third_party/WebKit/public/platform/WebString.h"
  21 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
  22 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  23 #include "third_party/WebKit/public/platform/WebVector.h"
  24 #include "third_party/WebKit/public/web/WebPlugin.h"
  25 #include "ui/gfx/native_widget_types.h"
  26 #include "url/gurl.h"
  27
  28 namespace cc {
  29 class IOSurfaceLayer;
  30 }
  31
  32 namespace blink {
  33 class WebFrame;
  34 class WebLayer;
  35 class WebPluginContainer;
  36 class WebURLResponse;
  37 class WebURLLoader;
  38 class WebURLRequest;
  39 }
  40
  41 namespace webkit_glue {
  42 class MultipartResponseDelegate;
  43 }  // namespace webkit_glue
  44
  45 namespace content {
  46 class RenderFrameImpl;
  47 class RenderViewImpl;
  48 class WebPluginDelegateProxy;
  49
  50 // This is the WebKit side of the plugin implementation that forwards calls,
  51 // after changing out of WebCore types, to a delegate.  The delegate may
  52 // be in a different process.
  53 class WebPluginImpl : public WebPlugin,
  54                       public blink::WebPlugin {
  55  public:
  56   WebPluginImpl(
  57       blink::WebFrame* frame,
  58       const blink::WebPluginParams& params,
  59       const base::FilePath& file_path,
  60       const base::WeakPtr<RenderViewImpl>& render_view,
  61       RenderFrameImpl* render_frame);
  62   virtual ~WebPluginImpl();
  63
  64   // Helper function for sorting post data.
  65   CONTENT_EXPORT static bool SetPostData(blink::WebURLRequest* request,
  66                                          const char* buf,
  67                                          uint32 length);
  68
  69   blink::WebFrame* webframe() { return webframe_; }
  70
  71   // blink::WebPlugin methods:
  72   virtual bool initialize(
  73       blink::WebPluginContainer* container);
  74   virtual void destroy();
  75   virtual NPObject* scriptableObject();
  76   virtual struct _NPP* pluginNPP();
  77   virtual bool getFormValue(blink::WebString& value);
  78   virtual void paint(
  79       blink::WebCanvas* canvas, const blink::WebRect& paint_rect);
  80   virtual void updateGeometry(
  81       const blink::WebRect& frame_rect, const blink::WebRect& clip_rect,
  82       const blink::WebVector<blink::WebRect>& cut_outs, bool is_visible);
  83   virtual void updateFocus(bool focused);
  84   virtual void updateVisibility(bool visible);
  85   virtual bool acceptsInputEvents();
  86   virtual bool handleInputEvent(
  87       const blink::WebInputEvent& event, blink::WebCursorInfo& cursor_info);
  88   virtual void didReceiveResponse(const blink::WebURLResponse& response);
  89   virtual void didReceiveData(const char* data, int data_length);
  90   virtual void didFinishLoading();
  91   virtual void didFailLoading(const blink::WebURLError& error);
  92   virtual void didFinishLoadingFrameRequest(
  93       const blink::WebURL& url, void* notify_data);
  94   virtual void didFailLoadingFrameRequest(
  95       const blink::WebURL& url, void* notify_data,
  96       const blink::WebURLError& error);
  97   virtual bool isPlaceholder() OVERRIDE;
  98
  99   // WebPlugin implementation:
 100   virtual void SetWindow(gfx::PluginWindowHandle window) OVERRIDE;
 101   virtual void SetAcceptsInputEvents(bool accepts) OVERRIDE;
 102   virtual void WillDestroyWindow(gfx::PluginWindowHandle window) OVERRIDE;
 103   virtual void CancelResource(unsigned long id) OVERRIDE;
 104   virtual void Invalidate() OVERRIDE;
 105   virtual void InvalidateRect(const gfx::Rect& rect) OVERRIDE;
 106   virtual NPObject* GetWindowScriptNPObject() OVERRIDE;
 107   virtual NPObject* GetPluginElement() OVERRIDE;
 108   virtual bool FindProxyForUrl(const GURL& url,
 109                                std::string* proxy_list) OVERRIDE;
 110   virtual void SetCookie(const GURL& url,
 111                          const GURL& first_party_for_cookies,
 112                          const std::string& cookie) OVERRIDE;
 113   virtual std::string GetCookies(const GURL& url,
 114                                  const GURL& first_party_for_cookies) OVERRIDE;
 115   virtual void HandleURLRequest(const char* url,
 116                                 const char *method,
 117                                 const char* target,
 118                                 const char* buf,
 119                                 unsigned int len,
 120                                 int notify_id,
 121                                 bool popups_allowed,
 122                                 bool notify_redirects) OVERRIDE;
 123   virtual void CancelDocumentLoad() OVERRIDE;
 124   virtual void InitiateHTTPRangeRequest(const char* url,
 125                                         const char* range_info,
 126                                         int pending_request_id) OVERRIDE;
 127   virtual void DidStartLoading() OVERRIDE;
 128   virtual void DidStopLoading() OVERRIDE;
 129   virtual bool IsOffTheRecord() OVERRIDE;
 130   virtual void SetDeferResourceLoading(unsigned long resource_id,
 131                                        bool defer) OVERRIDE;
 132   virtual void URLRedirectResponse(bool allow, int resource_id) OVERRIDE;
 133   virtual bool CheckIfRunInsecureContent(const GURL& url) OVERRIDE;
 134 #if defined(OS_WIN)
 135   void SetWindowlessData(HANDLE pump_messages_event,
 136                          gfx::NativeViewId dummy_activation_window) { }
 137   void ReparentPluginWindow(HWND window, HWND parent) { }
 138   void ReportExecutableMemory(size_t size) { }
 139 #endif
 140 #if defined(OS_MACOSX)
 141   virtual WebPluginAcceleratedSurface* GetAcceleratedSurface(
 142       gfx::GpuPreference gpu_preference) OVERRIDE;
 143   virtual void AcceleratedPluginEnabledRendering() OVERRIDE;
 144   virtual void AcceleratedPluginAllocatedIOSurface(int32 width,
 145                                                    int32 height,
 146                                                    uint32 surface_id) OVERRIDE;
 147   virtual void AcceleratedPluginSwappedIOSurface() OVERRIDE;
 148 #endif
 149
 150  private:
 151   // Given a (maybe partial) url, completes using the base url.
 152   GURL CompleteURL(const char* url);
 153
 154   enum RoutingStatus {
 155     ROUTED,
 156     NOT_ROUTED,
 157     INVALID_URL,
 158     GENERAL_FAILURE
 159   };
 160
 161   // Determines the referrer value sent along with outgoing HTTP requests
 162   // issued by plugins.
 163   enum Referrer {
 164     PLUGIN_SRC,
 165     DOCUMENT_URL,
 166     NO_REFERRER
 167   };
 168
 169   // Given a download request, check if we need to route the output to a frame.
 170   // Returns ROUTED if the load is done and routed to a frame, NOT_ROUTED or
 171   // corresponding error codes otherwise.
 172   RoutingStatus RouteToFrame(const char* url,
 173                              bool is_javascript_url,
 174                              bool popups_allowed,
 175                              const char* method,
 176                              const char* target,
 177                              const char* buf,
 178                              unsigned int len,
 179                              int notify_id,
 180                              Referrer referrer_flag);
 181
 182   // Returns the next avaiable resource id. Returns 0 if the operation fails.
 183   // It may fail if the page has already been closed.
 184   unsigned long GetNextResourceId();
 185
 186   // Initiates HTTP GET/POST requests.
 187   // Returns true on success.
 188   bool InitiateHTTPRequest(unsigned long resource_id,
 189                            WebPluginResourceClient* client,
 190                            const GURL& url,
 191                            const char* method,
 192                            const char* buf,
 193                            int len,
 194                            const char* range_info,
 195                            Referrer referrer_flag,
 196                            bool notify_redirects,
 197                            bool check_mixed_scripting);
 198
 199   gfx::Rect GetWindowClipRect(const gfx::Rect& rect);
 200
 201   // Sets the actual Widget for the plugin.
 202   void SetContainer(blink::WebPluginContainer* container);
 203
 204   // Destroys the plugin instance.
 205   // The response_handle_to_ignore parameter if not NULL indicates the
 206   // resource handle to be left valid during plugin shutdown.
 207   void TearDownPluginInstance(blink::WebURLLoader* loader_to_ignore);
 208
 209   // WebURLLoaderClient implementation.  We implement this interface in the
 210   // renderer process, and then use the simple WebPluginResourceClient interface
 211   // to relay the callbacks to the plugin.
 212   void willSendRequest(blink::WebURLLoader* loader,
 213                        blink::WebURLRequest& request,
 214                        const blink::WebURLResponse& response);
 215   void didSendData(blink::WebURLLoader* loader,
 216                    unsigned long long bytes_sent,
 217                    unsigned long long total_bytes_to_be_sent);
 218   void didReceiveResponse(blink::WebURLLoader* loader,
 219                                   const blink::WebURLResponse& response);
 220
 221   void didReceiveData(blink::WebURLLoader* loader, const char *buffer,
 222                       int data_length, int encoded_data_length);
 223   void didFinishLoading(blink::WebURLLoader* loader,
 224                         double finishTime);
 225   void didFail(blink::WebURLLoader* loader,
 226                const blink::WebURLError& error);
 227
 228   // Helper function to remove the stored information about a resource
 229   // request given its index in m_clients.
 230   void RemoveClient(size_t i);
 231
 232   // Helper function to remove the stored information about a resource
 233   // request given a handle.
 234   void RemoveClient(blink::WebURLLoader* loader);
 235
 236   // Handles HTTP multipart responses, i.e. responses received with a HTTP
 237   // status code of 206.
 238   // Returns false if response is not multipart (may be if we requested
 239   // single range).
 240   bool HandleHttpMultipartResponse(const blink::WebURLResponse& response,
 241                                    WebPluginResourceClient* client);
 242
 243   void HandleURLRequestInternal(const char* url,
 244                                 const char* method,
 245                                 const char* target,
 246                                 const char* buf,
 247                                 unsigned int len,
 248                                 int notify_id,
 249                                 bool popups_allowed,
 250                                 Referrer referrer_flag,
 251                                 bool notify_redirects,
 252                                 bool check_mixed_scripting);
 253
 254   // Tears down the existing plugin instance and creates a new plugin instance
 255   // to handle the response identified by the loader parameter.
 256   bool ReinitializePluginForResponse(blink::WebURLLoader* loader);
 257
 258   // Delayed task for downloading the plugin source URL.
 259   void OnDownloadPluginSrcUrl();
 260
 261   struct ClientInfo;
 262
 263   // Helper functions
 264   WebPluginResourceClient* GetClientFromLoader(blink::WebURLLoader* loader);
 265   ClientInfo* GetClientInfoFromLoader(blink::WebURLLoader* loader);
 266
 267   // Helper function to set the referrer on the request passed in.
 268   void SetReferrer(blink::WebURLRequest* request, Referrer referrer_flag);
 269
 270   // Check for invalid chars like @, ;, \ before the first / (in path).
 271   bool IsValidUrl(const GURL& url, Referrer referrer_flag);
 272
 273   std::vector<ClientInfo> clients_;
 274
 275   bool windowless_;
 276   gfx::PluginWindowHandle window_;
 277 #if defined(OS_MACOSX)
 278   bool next_io_surface_allocated_;
 279   int32 next_io_surface_width_;
 280   int32 next_io_surface_height_;
 281   uint32 next_io_surface_id_;
 282   scoped_refptr<cc::IOSurfaceLayer> io_surface_layer_;
 283   scoped_ptr<blink::WebLayer> web_layer_;
 284 #endif
 285   bool accepts_input_events_;
 286   RenderFrameImpl* render_frame_;
 287   base::WeakPtr<RenderViewImpl> render_view_;
 288   blink::WebFrame* webframe_;
 289
 290   WebPluginDelegateProxy* delegate_;
 291
 292   // This is just a weak reference.
 293   blink::WebPluginContainer* container_;
 294
 295   // Unique identifier for this plugin, used to track script objects.
 296   struct _NPP* npp_;
 297
 298   typedef std::map<WebPluginResourceClient*,
 299                    webkit_glue::MultipartResponseDelegate*>
 300       MultiPartResponseHandlerMap;
 301   // Tracks HTTP multipart response handlers instantiated for
 302   // a WebPluginResourceClient instance.
 303   MultiPartResponseHandlerMap multi_part_response_map_;
 304
 305   // The plugin source URL.
 306   GURL plugin_url_;
 307
 308   // Indicates if the download would be initiated by the plugin or us.
 309   bool load_manually_;
 310
 311   // Indicates if this is the first geometry update received by the plugin.
 312   bool first_geometry_update_;
 313
 314   // Set to true if the next response error should be ignored.
 315   bool ignore_response_error_;
 316
 317   // The current plugin geometry and clip rectangle.
 318   WebPluginGeometry geometry_;
 319
 320   // The location of the plugin on disk.
 321   base::FilePath file_path_;
 322
 323   // The mime type of the plugin.
 324   std::string mime_type_;
 325
 326   // Holds the list of argument names and values passed to the plugin.  We keep
 327   // these so that we can re-initialize the plugin if we need to.
 328   std::vector<std::string> arg_names_;
 329   std::vector<std::string> arg_values_;
 330
 331   base::WeakPtrFactory<WebPluginImpl> weak_factory_;
 332
 333   class LoaderClient : public blink::WebURLLoaderClient {
 334    public:
 335     LoaderClient(WebPluginImpl*);
 336
 337     virtual void willSendRequest(blink::WebURLLoader*,
 338                                  blink::WebURLRequest&,
 339                                  const blink::WebURLResponse&) OVERRIDE;
 340     virtual void didSendData(blink::WebURLLoader*,
 341                              unsigned long long bytesSent,
 342                              unsigned long long totalBytesToBeSent) OVERRIDE;
 343     virtual void didReceiveResponse(blink::WebURLLoader*,
 344                                     const blink::WebURLResponse&) OVERRIDE;
 345     virtual void didDownloadData(blink::WebURLLoader*,
 346                                  int dataLength,
 347                                  int encodedDataLength) OVERRIDE;
 348     virtual void didReceiveData(blink::WebURLLoader*,
 349                                 const char* data,
 350                                 int dataLength,
 351                                 int encodedDataLength) OVERRIDE;
 352     virtual void didReceiveCachedMetadata(blink::WebURLLoader*,
 353                                           const char* data,
 354                                           int dataLength) OVERRIDE;
 355     virtual void didFinishLoading(blink::WebURLLoader*,
 356                                   double finishTime,
 357                                   int64_t total_encoded_data_length) OVERRIDE;
 358     virtual void didFail(blink::WebURLLoader*,
 359                          const blink::WebURLError&) OVERRIDE;
 360
 361    private:
 362     WebPluginImpl* parent_;
 363   };
 364
 365   LoaderClient loader_client_;
 366
 367   DISALLOW_COPY_AND_ASSIGN(WebPluginImpl);
 368 };
 369
 370 }  // namespace content
 371
 372 #endif  // CONTENT_RENDERER_NPAPI_WEBPLUGIN_IMPL_H_