src/content/renderer/pepper/pepper_plugin_instance_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_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
   6 #define CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
   7
   8 #include <list>
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/callback.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/memory/weak_ptr.h"
  18 #include "base/strings/string16.h"
  19 #include "cc/layers/content_layer_client.h"
  20 #include "cc/layers/layer.h"
  21 #include "cc/layers/texture_layer_client.h"
  22 #include "content/common/content_export.h"
  23 #include "content/public/renderer/pepper_plugin_instance.h"
  24 #include "content/public/renderer/render_frame_observer.h"
  25 #include "content/renderer/mouse_lock_dispatcher.h"
  26 #include "gin/handle.h"
  27 #include "ppapi/c/dev/pp_cursor_type_dev.h"
  28 #include "ppapi/c/dev/ppp_printing_dev.h"
  29 #include "ppapi/c/dev/ppp_selection_dev.h"
  30 #include "ppapi/c/dev/ppp_text_input_dev.h"
  31 #include "ppapi/c/dev/ppp_zoom_dev.h"
  32 #include "ppapi/c/pp_completion_callback.h"
  33 #include "ppapi/c/pp_instance.h"
  34 #include "ppapi/c/pp_time.h"
  35 #include "ppapi/c/pp_var.h"
  36 #include "ppapi/c/ppb_audio_config.h"
  37 #include "ppapi/c/ppb_gamepad.h"
  38 #include "ppapi/c/ppb_input_event.h"
  39 #include "ppapi/c/ppp_graphics_3d.h"
  40 #include "ppapi/c/ppp_input_event.h"
  41 #include "ppapi/c/ppp_mouse_lock.h"
  42 #include "ppapi/c/private/ppb_content_decryptor_private.h"
  43 #include "ppapi/c/private/ppp_find_private.h"
  44 #include "ppapi/c/private/ppp_instance_private.h"
  45 #include "ppapi/c/private/ppp_pdf.h"
  46 #include "ppapi/shared_impl/ppb_instance_shared.h"
  47 #include "ppapi/shared_impl/ppb_view_shared.h"
  48 #include "ppapi/shared_impl/singleton_resource_id.h"
  49 #include "ppapi/shared_impl/tracked_callback.h"
  50 #include "ppapi/thunk/ppb_gamepad_api.h"
  51 #include "ppapi/thunk/resource_creation_api.h"
  52 #include "skia/ext/refptr.h"
  53 #include "third_party/WebKit/public/platform/WebCanvas.h"
  54 #include "third_party/WebKit/public/platform/WebString.h"
  55 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
  56 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  57 #include "third_party/WebKit/public/web/WebPlugin.h"
  58 #include "third_party/WebKit/public/web/WebUserGestureToken.h"
  59 #include "ui/base/ime/text_input_type.h"
  60 #include "ui/events/latency_info.h"
  61 #include "ui/gfx/rect.h"
  62 #include "url/gurl.h"
  63 #include "v8/include/v8.h"
  64
  65 struct PP_Point;
  66 struct _NPP;
  67
  68 class SkBitmap;
  69 class TransportDIB;
  70
  71 namespace blink {
  72 class WebInputEvent;
  73 class WebLayer;
  74 class WebMouseEvent;
  75 class WebPluginContainer;
  76 class WebURLLoader;
  77 class WebURLResponse;
  78 struct WebCompositionUnderline;
  79 struct WebCursorInfo;
  80 struct WebURLError;
  81 struct WebPrintParams;
  82 }
  83
  84 namespace cc {
  85 class TextureLayer;
  86 }
  87
  88 namespace gfx {
  89 class Range;
  90 }
  91
  92 namespace ppapi {
  93 class Resource;
  94 struct InputEventData;
  95 struct PPP_Instance_Combined;
  96 class ScopedPPVar;
  97 }
  98
  99 namespace content {
 100
 101 class ContentDecryptorDelegate;
 102 class FullscreenContainer;
 103 class MessageChannel;
 104 class PepperCompositorHost;
 105 class PepperGraphics2DHost;
 106 class PepperPluginInstanceThrottler;
 107 class PluginModule;
 108 class PluginObject;
 109 class PPB_Graphics3D_Impl;
 110 class PPB_ImageData_Impl;
 111 class PPB_URLLoader_Impl;
 112 class RenderFrameImpl;
 113 class RenderViewImpl;
 114
 115 // Represents one time a plugin appears on one web page.
 116 //
 117 // Note: to get from a PP_Instance to a PepperPluginInstance*, use the
 118 // ResourceTracker.
 119 class CONTENT_EXPORT PepperPluginInstanceImpl
 120     : public base::RefCounted<PepperPluginInstanceImpl>,
 121       public NON_EXPORTED_BASE(PepperPluginInstance),
 122       public ppapi::PPB_Instance_Shared,
 123       public NON_EXPORTED_BASE(cc::TextureLayerClient),
 124       public RenderFrameObserver {
 125  public:
 126   // Create and return a PepperPluginInstanceImpl object which supports the most
 127   // recent version of PPP_Instance possible by querying the given
 128   // get_plugin_interface function. If the plugin does not support any valid
 129   // PPP_Instance interface, returns NULL.
 130   static PepperPluginInstanceImpl* Create(RenderFrameImpl* render_frame,
 131                                           PluginModule* module,
 132                                           blink::WebPluginContainer* container,
 133                                           const GURL& plugin_url);
 134   RenderFrameImpl* render_frame() const { return render_frame_; }
 135   PluginModule* module() const { return module_.get(); }
 136
 137   blink::WebPluginContainer* container() const { return container_; }
 138
 139   // Returns the PP_Instance uniquely identifying this instance. Guaranteed
 140   // nonzero.
 141   PP_Instance pp_instance() const { return pp_instance_; }
 142
 143   ppapi::thunk::ResourceCreationAPI& resource_creation() {
 144     return *resource_creation_.get();
 145   }
 146
 147   MessageChannel* message_channel() { return message_channel_; }
 148   v8::Local<v8::Object> GetMessageChannelObject();
 149   // Called when |message_channel_| is destroyed as it may be destroyed prior to
 150   // the plugin being destroyed.
 151   void MessageChannelDestroyed();
 152
 153   // Return the v8 context for the frame that the plugin is contained in. Care
 154   // should be taken to use the correct context for plugin<->JS interactions.
 155   // In cases where JS calls into the plugin, the caller's context should
 156   // typically be used. When calling from the plugin into JS, this context
 157   // should typically used.
 158   v8::Local<v8::Context> GetMainWorldContext();
 159
 160   // Does some pre-destructor cleanup on the instance. This is necessary
 161   // because some cleanup depends on the plugin instance still existing (like
 162   // calling the plugin's DidDestroy function). This function is called from
 163   // the WebPlugin implementation when WebKit is about to remove the plugin.
 164   void Delete();
 165
 166   // Returns true if Delete() has been called on this object.
 167   bool is_deleted() const;
 168
 169   // Paints the current backing store to the web page.
 170   void Paint(blink::WebCanvas* canvas,
 171              const gfx::Rect& plugin_rect,
 172              const gfx::Rect& paint_rect);
 173
 174   // Schedules a paint of the page for the given region. The coordinates are
 175   // relative to the top-left of the plugin. This does nothing if the plugin
 176   // has not yet been positioned. You can supply an empty gfx::Rect() to
 177   // invalidate the entire plugin.
 178   void InvalidateRect(const gfx::Rect& rect);
 179
 180   // Schedules a scroll of the plugin.  This uses optimized scrolling only for
 181   // full-frame plugins, as otherwise there could be other elements on top.  The
 182   // slow path can also be triggered if there is an overlapping frame.
 183   void ScrollRect(int dx, int dy, const gfx::Rect& rect);
 184
 185   // Commit the backing texture to the screen once the side effects some
 186   // rendering up to an offscreen SwapBuffers are visible.
 187   void CommitBackingTexture();
 188
 189   // Called when the out-of-process plugin implementing this instance crashed.
 190   void InstanceCrashed();
 191
 192   // PPB_Instance and PPB_Instance_Private implementation.
 193   bool full_frame() const { return full_frame_; }
 194   const ppapi::ViewData& view_data() const { return view_data_; }
 195
 196   // PPP_Instance and PPP_Instance_Private.
 197   bool Initialize(const std::vector<std::string>& arg_names,
 198                   const std::vector<std::string>& arg_values,
 199                   bool full_frame);
 200   bool HandleDocumentLoad(const blink::WebURLResponse& response);
 201   bool HandleInputEvent(const blink::WebInputEvent& event,
 202                         blink::WebCursorInfo* cursor_info);
 203   PP_Var GetInstanceObject(v8::Isolate* isolate);
 204   void ViewChanged(const gfx::Rect& position,
 205                    const gfx::Rect& clip,
 206                    const std::vector<gfx::Rect>& cut_outs_rects);
 207
 208   // Handlers for composition events.
 209   bool HandleCompositionStart(const base::string16& text);
 210   bool HandleCompositionUpdate(
 211       const base::string16& text,
 212       const std::vector<blink::WebCompositionUnderline>& underlines,
 213       int selection_start,
 214       int selection_end);
 215   bool HandleCompositionEnd(const base::string16& text);
 216   bool HandleTextInput(const base::string16& text);
 217
 218   // Gets the current text input status.
 219   ui::TextInputType text_input_type() const { return text_input_type_; }
 220   gfx::Rect GetCaretBounds() const;
 221   bool IsPluginAcceptingCompositionEvents() const;
 222   void GetSurroundingText(base::string16* text, gfx::Range* range) const;
 223
 224   // Notifications about focus changes, see has_webkit_focus_ below.
 225   void SetWebKitFocus(bool has_focus);
 226   void SetContentAreaFocus(bool has_focus);
 227
 228   // Notification about page visibility. The default is "visible".
 229   void PageVisibilityChanged(bool is_visible);
 230
 231   // Notifications that the view has started painting, and has flushed the
 232   // painted content to the screen. These messages are used to send Flush
 233   // callbacks to the plugin for DeviceContext2D/3D.
 234   void ViewInitiatedPaint();
 235   void ViewFlushedPaint();
 236
 237   // Tracks all live PluginObjects.
 238   void AddPluginObject(PluginObject* plugin_object);
 239   void RemovePluginObject(PluginObject* plugin_object);
 240
 241   base::string16 GetSelectedText(bool html);
 242   base::string16 GetLinkAtPosition(const gfx::Point& point);
 243   void RequestSurroundingText(size_t desired_number_of_characters);
 244   void Zoom(double factor, bool text_only);
 245   bool StartFind(const base::string16& search_text,
 246                  bool case_sensitive,
 247                  int identifier);
 248   void SelectFindResult(bool forward);
 249   void StopFind();
 250
 251   bool SupportsPrintInterface();
 252   bool IsPrintScalingDisabled();
 253   int PrintBegin(const blink::WebPrintParams& print_params);
 254   bool PrintPage(int page_number, blink::WebCanvas* canvas);
 255   void PrintEnd();
 256
 257   bool CanRotateView();
 258   void RotateView(blink::WebPlugin::RotationType type);
 259
 260   // There are 2 implementations of the fullscreen interface
 261   // PPB_FlashFullscreen is used by Pepper Flash.
 262   // PPB_Fullscreen is intended for other applications including NaCl.
 263   // The two interface are mutually exclusive.
 264
 265   // Implementation of PPB_FlashFullscreen.
 266
 267   // Because going to fullscreen is asynchronous (but going out is not), there
 268   // are 3 states:
 269   // - normal            : fullscreen_container_ == NULL
 270   //                       flash_fullscreen_ == false
 271   // - fullscreen pending: fullscreen_container_ != NULL
 272   //                       flash_fullscreen_ == false
 273   // - fullscreen        : fullscreen_container_ != NULL
 274   //                       flash_fullscreen_ == true
 275   //
 276   // In normal state, events come from webkit and painting goes back to it.
 277   // In fullscreen state, events come from the fullscreen container, and
 278   // painting goes back to it.
 279   // In pending state, events from webkit are ignored, and as soon as we
 280   // receive events from the fullscreen container, we go to the fullscreen
 281   // state.
 282   bool FlashIsFullscreenOrPending();
 283
 284   // Updates |flash_fullscreen_| and sends focus change notification if
 285   // necessary.
 286   void UpdateFlashFullscreenState(bool flash_fullscreen);
 287
 288   FullscreenContainer* fullscreen_container() const {
 289     return fullscreen_container_;
 290   }
 291
 292   // Implementation of PPB_Fullscreen.
 293
 294   // Because going to/from fullscreen is asynchronous, there are 4 states:
 295   // - normal            : desired_fullscreen_state_ == false
 296   //                       view_data_.is_fullscreen == false
 297   // - fullscreen pending: desired_fullscreen_state_ == true
 298   //                       view_data_.is_fullscreen == false
 299   // - fullscreen        : desired_fullscreen_state_ == true
 300   //                       view_data_.is_fullscreen == true
 301   // - normal pending    : desired_fullscreen_state_ = false
 302   //                       view_data_.is_fullscreen = true
 303   bool IsFullscreenOrPending();
 304
 305   bool flash_fullscreen() const { return flash_fullscreen_; }
 306
 307   // Switches between fullscreen and normal mode. The transition is
 308   // asynchronous. WebKit will trigger corresponding VewChanged calls.
 309   // Returns true on success, false on failure (e.g. trying to enter fullscreen
 310   // when not processing a user gesture or trying to set fullscreen when
 311   // already in fullscreen mode).
 312   bool SetFullscreen(bool fullscreen);
 313
 314   // Send the message on to the plugin.
 315   void HandleMessage(ppapi::ScopedPPVar message);
 316
 317   // Send the message synchronously to the plugin, and get a result. Returns
 318   // true if the plugin handled the message, false if it didn't. The plugin
 319   // won't handle the message if it has not registered a PPP_MessageHandler.
 320   bool HandleBlockingMessage(ppapi::ScopedPPVar message,
 321                              ppapi::ScopedPPVar* result);
 322
 323   // Returns true if the plugin is processing a user gesture.
 324   bool IsProcessingUserGesture();
 325
 326   // Returns the user gesture token to use for creating a WebScopedUserGesture,
 327   // if IsProcessingUserGesture returned true.
 328   blink::WebUserGestureToken CurrentUserGestureToken();
 329
 330   // A mouse lock request was pending and this reports success or failure.
 331   void OnLockMouseACK(bool succeeded);
 332   // A mouse lock was in place, but has been lost.
 333   void OnMouseLockLost();
 334   // A mouse lock is enabled and mouse events are being delivered.
 335   void HandleMouseLockedInputEvent(const blink::WebMouseEvent& event);
 336
 337   // Simulates an input event to the plugin by passing it down to WebKit,
 338   // which sends it back up to the plugin as if it came from the user.
 339   void SimulateInputEvent(const ppapi::InputEventData& input_event);
 340
 341   // Simulates an IME event at the level of RenderView which sends it back up to
 342   // the plugin as if it came from the user.
 343   bool SimulateIMEEvent(const ppapi::InputEventData& input_event);
 344   void SimulateImeSetCompositionEvent(const ppapi::InputEventData& input_event);
 345
 346   // The document loader is valid when the plugin is "full-frame" and in this
 347   // case is non-NULL as long as the corresponding loader resource is alive.
 348   // This pointer is non-owning, so the loader must use set_document_loader to
 349   // clear itself when it is destroyed.
 350   blink::WebURLLoaderClient* document_loader() const {
 351     return document_loader_;
 352   }
 353   void set_document_loader(blink::WebURLLoaderClient* loader) {
 354     document_loader_ = loader;
 355   }
 356
 357   ContentDecryptorDelegate* GetContentDecryptorDelegate();
 358
 359   // PluginInstance implementation
 360   RenderView* GetRenderView() override;
 361   blink::WebPluginContainer* GetContainer() override;
 362   v8::Isolate* GetIsolate() const override;
 363   ppapi::VarTracker* GetVarTracker() override;
 364   const GURL& GetPluginURL() override;
 365   base::FilePath GetModulePath() override;
 366   PP_Resource CreateImage(gfx::ImageSkia* source_image, float scale) override;
 367   PP_ExternalPluginResult SwitchToOutOfProcessProxy(
 368       const base::FilePath& file_path,
 369       ppapi::PpapiPermissions permissions,
 370       const IPC::ChannelHandle& channel_handle,
 371       base::ProcessId plugin_pid,
 372       int plugin_child_id) override;
 373   void SetAlwaysOnTop(bool on_top) override;
 374   bool IsFullPagePlugin() override;
 375   bool FlashSetFullscreen(bool fullscreen, bool delay_report) override;
 376   bool IsRectTopmost(const gfx::Rect& rect) override;
 377   int32_t Navigate(const ppapi::URLRequestInfoData& request,
 378                    const char* target,
 379                    bool from_user_action) override;
 380   int MakePendingFileRefRendererHost(const base::FilePath& path) override;
 381   void SetEmbedProperty(PP_Var key, PP_Var value) override;
 382   void SetSelectedText(const base::string16& selected_text) override;
 383   void SetLinkUnderCursor(const std::string& url) override;
 384   void SetTextInputType(ui::TextInputType type) override;
 385   void PostMessageToJavaScript(PP_Var message) override;
 386
 387   // PPB_Instance_API implementation.
 388   PP_Bool BindGraphics(PP_Instance instance, PP_Resource device) override;
 389   PP_Bool IsFullFrame(PP_Instance instance) override;
 390   const ppapi::ViewData* GetViewData(PP_Instance instance) override;
 391   PP_Bool FlashIsFullscreen(PP_Instance instance) override;
 392   PP_Var GetWindowObject(PP_Instance instance) override;
 393   PP_Var GetOwnerElementObject(PP_Instance instance) override;
 394   PP_Var ExecuteScript(PP_Instance instance,
 395                        PP_Var script,
 396                        PP_Var* exception) override;
 397   uint32_t GetAudioHardwareOutputSampleRate(PP_Instance instance) override;
 398   uint32_t GetAudioHardwareOutputBufferSize(PP_Instance instance) override;
 399   PP_Var GetDefaultCharSet(PP_Instance instance) override;
 400   void SetPluginToHandleFindRequests(PP_Instance) override;
 401   void NumberOfFindResultsChanged(PP_Instance instance,
 402                                   int32_t total,
 403                                   PP_Bool final_result) override;
 404   void SelectedFindResultChanged(PP_Instance instance, int32_t index) override;
 405   void SetTickmarks(PP_Instance instance,
 406                     const PP_Rect* tickmarks,
 407                     uint32_t count) override;
 408   PP_Bool IsFullscreen(PP_Instance instance) override;
 409   PP_Bool SetFullscreen(PP_Instance instance, PP_Bool fullscreen) override;
 410   PP_Bool GetScreenSize(PP_Instance instance, PP_Size* size) override;
 411   ppapi::Resource* GetSingletonResource(PP_Instance instance,
 412                                         ppapi::SingletonResourceID id) override;
 413   int32_t RequestInputEvents(PP_Instance instance,
 414                              uint32_t event_classes) override;
 415   int32_t RequestFilteringInputEvents(PP_Instance instance,
 416                                       uint32_t event_classes) override;
 417   void ClearInputEventRequest(PP_Instance instance,
 418                               uint32_t event_classes) override;
 419   void StartTrackingLatency(PP_Instance instance) override;
 420   void ZoomChanged(PP_Instance instance, double factor) override;
 421   void ZoomLimitsChanged(PP_Instance instance,
 422                          double minimum_factor,
 423                          double maximum_factor) override;
 424   void PostMessage(PP_Instance instance, PP_Var message) override;
 425   int32_t RegisterMessageHandler(PP_Instance instance,
 426                                  void* user_data,
 427                                  const PPP_MessageHandler_0_2* handler,
 428                                  PP_Resource message_loop) override;
 429   int32_t RegisterMessageHandler_1_1_Deprecated(
 430       PP_Instance instance,
 431       void* user_data,
 432       const PPP_MessageHandler_0_1_Deprecated* handler,
 433       PP_Resource message_loop) override;
 434   void UnregisterMessageHandler(PP_Instance instance) override;
 435   PP_Bool SetCursor(PP_Instance instance,
 436                     PP_MouseCursor_Type type,
 437                     PP_Resource image,
 438                     const PP_Point* hot_spot) override;
 439   int32_t LockMouse(PP_Instance instance,
 440                     scoped_refptr<ppapi::TrackedCallback> callback) override;
 441   void UnlockMouse(PP_Instance instance) override;
 442   void SetTextInputType(PP_Instance instance, PP_TextInput_Type type) override;
 443   void UpdateCaretPosition(PP_Instance instance,
 444                            const PP_Rect& caret,
 445                            const PP_Rect& bounding_box) override;
 446   void CancelCompositionText(PP_Instance instance) override;
 447   void SelectionChanged(PP_Instance instance) override;
 448   void UpdateSurroundingText(PP_Instance instance,
 449                              const char* text,
 450                              uint32_t caret,
 451                              uint32_t anchor) override;
 452   PP_Var ResolveRelativeToDocument(PP_Instance instance,
 453                                    PP_Var relative,
 454                                    PP_URLComponents_Dev* components) override;
 455   PP_Bool DocumentCanRequest(PP_Instance instance, PP_Var url) override;
 456   PP_Bool DocumentCanAccessDocument(PP_Instance instance,
 457                                     PP_Instance target) override;
 458   PP_Var GetDocumentURL(PP_Instance instance,
 459                         PP_URLComponents_Dev* components) override;
 460   PP_Var GetPluginInstanceURL(PP_Instance instance,
 461                               PP_URLComponents_Dev* components) override;
 462   PP_Var GetPluginReferrerURL(PP_Instance instance,
 463                               PP_URLComponents_Dev* components) override;
 464
 465   // PPB_ContentDecryptor_Private implementation.
 466   void PromiseResolved(PP_Instance instance, uint32 promise_id) override;
 467   void PromiseResolvedWithSession(PP_Instance instance,
 468                                   uint32 promise_id,
 469                                   PP_Var web_session_id_var) override;
 470   void PromiseResolvedWithKeyIds(PP_Instance instance,
 471                                  uint32 promise_id,
 472                                  PP_Var key_ids_var) override;
 473   void PromiseRejected(PP_Instance instance,
 474                        uint32 promise_id,
 475                        PP_CdmExceptionCode exception_code,
 476                        uint32 system_code,
 477                        PP_Var error_description_var) override;
 478   void SessionMessage(PP_Instance instance,
 479                       PP_Var web_session_id_var,
 480                       PP_Var message_var,
 481                       PP_Var destination_url_var) override;
 482   void SessionKeysChange(PP_Instance instance,
 483                          PP_Var web_session_id_var,
 484                          PP_Bool has_additional_usable_key) override;
 485   void SessionExpirationChange(PP_Instance instance,
 486                                PP_Var web_session_id_var,
 487                                PP_Time new_expiry_time) override;
 488   void SessionReady(PP_Instance instance, PP_Var web_session_id_var) override;
 489   void SessionClosed(PP_Instance instance, PP_Var web_session_id_var) override;
 490   void SessionError(PP_Instance instance,
 491                     PP_Var web_session_id_var,
 492                     PP_CdmExceptionCode exception_code,
 493                     uint32 system_code,
 494                     PP_Var error_description_var) override;
 495   void DeliverBlock(PP_Instance instance,
 496                     PP_Resource decrypted_block,
 497                     const PP_DecryptedBlockInfo* block_info) override;
 498   void DecoderInitializeDone(PP_Instance instance,
 499                              PP_DecryptorStreamType decoder_type,
 500                              uint32_t request_id,
 501                              PP_Bool success) override;
 502   void DecoderDeinitializeDone(PP_Instance instance,
 503                                PP_DecryptorStreamType decoder_type,
 504                                uint32_t request_id) override;
 505   void DecoderResetDone(PP_Instance instance,
 506                         PP_DecryptorStreamType decoder_type,
 507                         uint32_t request_id) override;
 508   void DeliverFrame(PP_Instance instance,
 509                     PP_Resource decrypted_frame,
 510                     const PP_DecryptedFrameInfo* frame_info) override;
 511   void DeliverSamples(PP_Instance instance,
 512                       PP_Resource audio_frames,
 513                       const PP_DecryptedSampleInfo* sample_info) override;
 514
 515   // Reset this instance as proxied. Assigns the instance a new module, resets
 516   // cached interfaces to point to the out-of-process proxy and re-sends
 517   // DidCreate, DidChangeView, and HandleDocumentLoad (if necessary).
 518   // This should be used only when switching an in-process instance to an
 519   // external out-of-process instance.
 520   PP_ExternalPluginResult ResetAsProxied(scoped_refptr<PluginModule> module);
 521
 522   // Checks whether this is a valid instance of the given module. After calling
 523   // ResetAsProxied above, a NaCl plugin instance's module changes, so external
 524   // hosts won't recognize it as a valid instance of the original module. This
 525   // method fixes that be checking that either module_ or original_module_ match
 526   // the given module.
 527   bool IsValidInstanceOf(PluginModule* module);
 528
 529   // cc::TextureLayerClient implementation.
 530   bool PrepareTextureMailbox(
 531       cc::TextureMailbox* mailbox,
 532       scoped_ptr<cc::SingleReleaseCallback>* release_callback,
 533       bool use_shared_memory) override;
 534
 535   // RenderFrameObserver
 536   void OnDestruct() override;
 537
 538   void AddLatencyInfo(const std::vector<ui::LatencyInfo>& latency_info);
 539
 540  private:
 541   friend class base::RefCounted<PepperPluginInstanceImpl>;
 542   friend class PpapiPluginInstanceTest;
 543   friend class PpapiUnittest;
 544
 545   // Delete should be called by the WebPlugin before this destructor.
 546   ~PepperPluginInstanceImpl() override;
 547
 548   // Class to record document load notifications and play them back once the
 549   // real document loader becomes available. Used only by external instances.
 550   class ExternalDocumentLoader : public blink::WebURLLoaderClient {
 551    public:
 552     ExternalDocumentLoader();
 553     virtual ~ExternalDocumentLoader();
 554
 555     void ReplayReceivedData(WebURLLoaderClient* document_loader);
 556
 557     // blink::WebURLLoaderClient implementation.
 558     virtual void didReceiveData(blink::WebURLLoader* loader,
 559                                 const char* data,
 560                                 int data_length,
 561                                 int encoded_data_length);
 562     virtual void didFinishLoading(blink::WebURLLoader* loader,
 563                                   double finish_time,
 564                                   int64_t total_encoded_data_length);
 565     virtual void didFail(blink::WebURLLoader* loader,
 566                          const blink::WebURLError& error);
 567
 568    private:
 569     std::list<std::string> data_;
 570     bool finished_loading_;
 571     scoped_ptr<blink::WebURLError> error_;
 572   };
 573
 574   // Implements PPB_Gamepad_API. This is just to avoid having an excessive
 575   // number of interfaces implemented by PepperPluginInstanceImpl.
 576   class GamepadImpl : public ppapi::thunk::PPB_Gamepad_API,
 577                       public ppapi::Resource {
 578    public:
 579     GamepadImpl();
 580     // Resource implementation.
 581     ppapi::thunk::PPB_Gamepad_API* AsPPB_Gamepad_API() override;
 582     void Sample(PP_Instance instance, PP_GamepadsSampleData* data) override;
 583
 584    private:
 585     ~GamepadImpl() override;
 586   };
 587
 588   // See the static Create functions above for creating PepperPluginInstanceImpl
 589   // objects. This constructor is private so that we can hide the
 590   // PPP_Instance_Combined details while still having 1 constructor to maintain
 591   // for member initialization.
 592   PepperPluginInstanceImpl(RenderFrameImpl* render_frame,
 593                            PluginModule* module,
 594                            ppapi::PPP_Instance_Combined* instance_interface,
 595                            blink::WebPluginContainer* container,
 596                            const GURL& plugin_url);
 597
 598   bool LoadFindInterface();
 599   bool LoadInputEventInterface();
 600   bool LoadMouseLockInterface();
 601   bool LoadPdfInterface();
 602   bool LoadPrintInterface();
 603   bool LoadPrivateInterface();
 604   bool LoadTextInputInterface();
 605   bool LoadZoomInterface();
 606
 607   // Update any transforms that should be applied to the texture layer.
 608   void UpdateLayerTransform();
 609
 610   // Determines if we think the plugin has focus, both content area and webkit
 611   // (see has_webkit_focus_ below).
 612   bool PluginHasFocus() const;
 613   void SendFocusChangeNotification();
 614
 615   void UpdateTouchEventRequest();
 616
 617   // Returns true if the plugin has registered to accept wheel events.
 618   bool IsAcceptingWheelEvents() const;
 619
 620   void ScheduleAsyncDidChangeView();
 621   void SendAsyncDidChangeView();
 622   void SendDidChangeView();
 623
 624   // Reports the current plugin geometry to the plugin by calling
 625   // DidChangeView.
 626   void ReportGeometry();
 627
 628   // Queries the plugin for supported print formats and sets |format| to the
 629   // best format to use. Returns false if the plugin does not support any
 630   // print format that we can handle (we can handle only PDF).
 631   bool GetPreferredPrintOutputFormat(PP_PrintOutputFormat_Dev* format);
 632   bool PrintPDFOutput(PP_Resource print_output, blink::WebCanvas* canvas);
 633
 634   // Updates the layer for compositing. This creates a layer and attaches to the
 635   // container if:
 636   // - we have a bound Graphics3D and the Graphics3D has a texture, OR
 637   //   we have a bound Graphics2D and are using software compositing
 638   // - we are not in Flash full-screen mode (or transitioning to it)
 639   // Otherwise it destroys the layer.
 640   // It does either operation lazily.
 641   // device_changed: true if the bound device has been changed, and
 642   // UpdateLayer() will be forced to recreate the layer and attaches to the
 643   // container.
 644   void UpdateLayer(bool device_changed);
 645
 646   // Internal helper function for PrintPage().
 647   bool PrintPageHelper(PP_PrintPageNumberRange_Dev* page_ranges,
 648                        int num_ranges,
 649                        blink::WebCanvas* canvas);
 650
 651   void DoSetCursor(blink::WebCursorInfo* cursor);
 652
 653   // Internal helper functions for HandleCompositionXXX().
 654   bool SendCompositionEventToPlugin(PP_InputEvent_Type type,
 655                                     const base::string16& text);
 656   bool SendCompositionEventWithUnderlineInformationToPlugin(
 657       PP_InputEvent_Type type,
 658       const base::string16& text,
 659       const std::vector<blink::WebCompositionUnderline>& underlines,
 660       int selection_start,
 661       int selection_end);
 662
 663   // Internal helper function for XXXInputEvents().
 664   void RequestInputEventsHelper(uint32_t event_classes);
 665
 666   // Checks if the security origin of the document containing this instance can
 667   // assess the security origin of the main frame document.
 668   bool CanAccessMainFrame() const;
 669
 670   // Returns true if the WebView the plugin is in renders via the accelerated
 671   // compositing path.
 672   bool IsViewAccelerated();
 673
 674   // Track, set and reset size attributes to control the size of the plugin
 675   // in and out of fullscreen mode.
 676   void KeepSizeAttributesBeforeFullscreen();
 677   void SetSizeAttributesForFullscreen();
 678   void ResetSizeAttributesAfterFullscreen();
 679
 680   bool IsMouseLocked();
 681   bool LockMouse();
 682   MouseLockDispatcher* GetMouseLockDispatcher();
 683   MouseLockDispatcher::LockTarget* GetOrCreateLockTargetAdapter();
 684   void UnSetAndDeleteLockTargetAdapter();
 685
 686   void DidDataFromWebURLResponse(const blink::WebURLResponse& response,
 687                                  int pending_host_id,
 688                                  const ppapi::URLResponseInfoData& data);
 689
 690   void SetPluginThrottled(bool throttled);
 691   void DisablePowerSaverByRetroactiveWhitelist();
 692
 693   RenderFrameImpl* render_frame_;
 694   base::Closure instance_deleted_callback_;
 695   scoped_refptr<PluginModule> module_;
 696   scoped_ptr<ppapi::PPP_Instance_Combined> instance_interface_;
 697   // If this is the NaCl plugin, we create a new module when we switch to the
 698   // IPC-based PPAPI proxy. Store the original module and instance interface
 699   // so we can shut down properly.
 700   scoped_refptr<PluginModule> original_module_;
 701   scoped_ptr<ppapi::PPP_Instance_Combined> original_instance_interface_;
 702
 703   PP_Instance pp_instance_;
 704
 705   // NULL until we have been initialized.
 706   blink::WebPluginContainer* container_;
 707   scoped_refptr<cc::Layer> compositor_layer_;
 708   scoped_refptr<cc::TextureLayer> texture_layer_;
 709   scoped_ptr<blink::WebLayer> web_layer_;
 710   bool layer_bound_to_fullscreen_;
 711   bool layer_is_hardware_;
 712
 713   // Plugin URL.
 714   GURL plugin_url_;
 715
 716   // Set to true first time plugin is clicked. Used to collect metrics.
 717   bool has_been_clicked_;
 718
 719   // Indicates whether this plugin may be throttled to reduce power consumption.
 720   // |power_saver_enabled_| implies |is_peripheral_content_|.
 721   bool power_saver_enabled_;
 722
 723   // Indicates whether this plugin was found to be peripheral content.
 724   // This is separately tracked from |power_saver_enabled_| to collect UMAs.
 725   // Always true if |power_saver_enabled_| is true.
 726   bool is_peripheral_content_;
 727
 728   // Indicates if the plugin is currently throttled.
 729   bool plugin_throttled_;
 730
 731   // Fake view data used by the Power Saver feature to throttle plugins.
 732   const ppapi::ViewData empty_view_data_;
 733
 734   // Responsible for turning on throttling if Power Saver is on.
 735   scoped_ptr<PepperPluginInstanceThrottler> throttler_;
 736
 737   // Indicates whether this is a full frame instance, which means it represents
 738   // an entire document rather than an embed tag.
 739   bool full_frame_;
 740
 741   // Stores the current state of the plugin view.
 742   ppapi::ViewData view_data_;
 743   // The last state sent to the plugin. It is only valid after
 744   // |sent_initial_did_change_view_| is set to true.
 745   ppapi::ViewData last_sent_view_data_;
 746
 747   // Indicates if we've ever sent a didChangeView to the plugin. This ensures we
 748   // always send an initial notification, even if the position and clip are the
 749   // same as the default values.
 750   bool sent_initial_did_change_view_;
 751
 752   // The current device context for painting in 2D, 3D or compositor.
 753   scoped_refptr<PPB_Graphics3D_Impl> bound_graphics_3d_;
 754   PepperGraphics2DHost* bound_graphics_2d_platform_;
 755   PepperCompositorHost* bound_compositor_;
 756
 757   // We track two types of focus, one from WebKit, which is the focus among
 758   // all elements of the page, one one from the browser, which is whether the
 759   // tab/window has focus. We tell the plugin it has focus only when both of
 760   // these values are set to true.
 761   bool has_webkit_focus_;
 762   bool has_content_area_focus_;
 763
 764   // The id of the current find operation, or -1 if none is in process.
 765   int find_identifier_;
 766
 767   // Helper object that creates resources.
 768   scoped_ptr<ppapi::thunk::ResourceCreationAPI> resource_creation_;
 769
 770   // The plugin-provided interfaces.
 771   // When adding PPP interfaces, make sure to reset them in ResetAsProxied.
 772   const PPP_Find_Private* plugin_find_interface_;
 773   const PPP_InputEvent* plugin_input_event_interface_;
 774   const PPP_MouseLock* plugin_mouse_lock_interface_;
 775   const PPP_Pdf* plugin_pdf_interface_;
 776   const PPP_Instance_Private* plugin_private_interface_;
 777   const PPP_TextInput_Dev* plugin_textinput_interface_;
 778   const PPP_Zoom_Dev* plugin_zoom_interface_;
 779
 780   // Flags indicating whether we have asked this plugin instance for the
 781   // corresponding interfaces, so that we can ask only once.
 782   // When adding flags, make sure to reset them in ResetAsProxied.
 783   bool checked_for_plugin_input_event_interface_;
 784   bool checked_for_plugin_pdf_interface_;
 785
 786   // This is only valid between a successful PrintBegin call and a PrintEnd
 787   // call.
 788   PP_PrintSettings_Dev current_print_settings_;
 789 #if defined(OS_MACOSX)
 790   // On the Mac, when we draw the bitmap to the PDFContext, it seems necessary
 791   // to keep the pixels valid until CGContextEndPage is called. We use this
 792   // variable to hold on to the pixels.
 793   scoped_refptr<PPB_ImageData_Impl> last_printed_page_;
 794 #endif  // defined(OS_MACOSX)
 795   // Always when printing to PDF on Linux and when printing for preview on Mac
 796   // and Win, the entire document goes into one metafile.  However, when users
 797   // print only a subset of all the pages, it is impossible to know if a call
 798   // to PrintPage() is the last call. Thus in PrintPage(), just store the page
 799   // number in |ranges_|. The hack is in PrintEnd(), where a valid |canvas_|
 800   // is preserved in PrintWebViewHelper::PrintPages. This makes it possible
 801   // to generate the entire PDF given the variables below:
 802   //
 803   // The most recently used WebCanvas, guaranteed to be valid.
 804   skia::RefPtr<blink::WebCanvas> canvas_;
 805   // An array of page ranges.
 806   std::vector<PP_PrintPageNumberRange_Dev> ranges_;
 807
 808   scoped_refptr<ppapi::Resource> gamepad_impl_;
 809   scoped_refptr<ppapi::Resource> uma_private_impl_;
 810
 811   // The plugin print interface.
 812   const PPP_Printing_Dev* plugin_print_interface_;
 813
 814   // The plugin 3D interface.
 815   const PPP_Graphics3D* plugin_graphics_3d_interface_;
 816
 817   // Contains the cursor if it's set by the plugin.
 818   scoped_ptr<blink::WebCursorInfo> cursor_;
 819
 820   // Set to true if this plugin thinks it will always be on top. This allows us
 821   // to use a more optimized painting path in some cases.
 822   bool always_on_top_;
 823   // Even if |always_on_top_| is true, the plugin is not fully visible if there
 824   // are some cut-out areas (occupied by iframes higher in the stacking order).
 825   // This information is used in the optimized painting path.
 826   std::vector<gfx::Rect> cut_outs_rects_;
 827
 828   // Implementation of PPB_FlashFullscreen.
 829
 830   // Plugin container for fullscreen mode. NULL if not in fullscreen mode. Note:
 831   // there is a transition state where fullscreen_container_ is non-NULL but
 832   // flash_fullscreen_ is false (see above).
 833   FullscreenContainer* fullscreen_container_;
 834
 835   // True if we are in "flash" fullscreen mode. False if we are in normal mode
 836   // or in transition to fullscreen. Normal fullscreen mode is indicated in
 837   // the ViewData.
 838   bool flash_fullscreen_;
 839
 840   // Implementation of PPB_Fullscreen.
 841
 842   // Since entering fullscreen mode is an asynchronous operation, we set this
 843   // variable to the desired state at the time we issue the fullscreen change
 844   // request. The plugin will receive a DidChangeView event when it goes
 845   // fullscreen.
 846   bool desired_fullscreen_state_;
 847
 848   // WebKit does not resize the plugin when going into fullscreen mode, so we do
 849   // this here by modifying the various plugin attributes and then restoring
 850   // them on exit.
 851   blink::WebString width_before_fullscreen_;
 852   blink::WebString height_before_fullscreen_;
 853   blink::WebString border_before_fullscreen_;
 854   blink::WebString style_before_fullscreen_;
 855   gfx::Size screen_size_for_fullscreen_;
 856
 857   // The MessageChannel used to implement bidirectional postMessage for the
 858   // instance.
 859   v8::Persistent<v8::Object> message_channel_object_;
 860
 861   // A pointer to the MessageChannel underlying |message_channel_object_|. It is
 862   // only valid as long as |message_channel_object_| is alive.
 863   MessageChannel* message_channel_;
 864
 865   // Bitmap for crashed plugin. Lazily initialized, non-owning pointer.
 866   SkBitmap* sad_plugin_;
 867
 868   typedef std::set<PluginObject*> PluginObjectSet;
 869   PluginObjectSet live_plugin_objects_;
 870
 871   // Classes of events that the plugin has registered for, both for filtering
 872   // and not. The bits are PP_INPUTEVENT_CLASS_*.
 873   uint32_t input_event_mask_;
 874   uint32_t filtered_input_event_mask_;
 875
 876   // Text composition status.
 877   ui::TextInputType text_input_type_;
 878   gfx::Rect text_input_caret_;
 879   gfx::Rect text_input_caret_bounds_;
 880   bool text_input_caret_set_;
 881
 882   // Text selection status.
 883   std::string surrounding_text_;
 884   size_t selection_caret_;
 885   size_t selection_anchor_;
 886
 887   scoped_refptr<ppapi::TrackedCallback> lock_mouse_callback_;
 888
 889   // Track pending user gestures so out-of-process plugins can respond to
 890   // a user gesture after it has been processed.
 891   PP_TimeTicks pending_user_gesture_;
 892   blink::WebUserGestureToken pending_user_gesture_token_;
 893
 894   // We store the arguments so we can re-send them if we are reset to talk to
 895   // NaCl via the IPC NaCl proxy.
 896   std::vector<std::string> argn_;
 897   std::vector<std::string> argv_;
 898
 899   // Non-owning pointer to the document loader, if any.
 900   blink::WebURLLoaderClient* document_loader_;
 901   // State for deferring document loads. Used only by external instances.
 902   blink::WebURLResponse external_document_response_;
 903   scoped_ptr<ExternalDocumentLoader> external_document_loader_;
 904   bool external_document_load_;
 905
 906   // The ContentDecryptorDelegate forwards PPP_ContentDecryptor_Private
 907   // calls and handles PPB_ContentDecryptor_Private calls.
 908   scoped_ptr<ContentDecryptorDelegate> content_decryptor_delegate_;
 909
 910   // The link currently under the cursor.
 911   base::string16 link_under_cursor_;
 912
 913   // We store the isolate at construction so that we can be sure to use the
 914   // Isolate in which this Instance was created when interacting with v8.
 915   v8::Isolate* isolate_;
 916
 917   scoped_ptr<MouseLockDispatcher::LockTarget> lock_target_;
 918
 919   bool is_deleted_;
 920
 921   // The text that is currently selected in the plugin.
 922   base::string16 selected_text_;
 923
 924   int64 last_input_number_;
 925
 926   bool is_tracking_latency_;
 927
 928   // We use a weak ptr factory for scheduling DidChangeView events so that we
 929   // can tell whether updates are pending and consolidate them. When there's
 930   // already a weak ptr pending (HasWeakPtrs is true), code should update the
 931   // view_data_ but not send updates. This also allows us to cancel scheduled
 932   // view change events.
 933   base::WeakPtrFactory<PepperPluginInstanceImpl> view_change_weak_ptr_factory_;
 934   base::WeakPtrFactory<PepperPluginInstanceImpl> weak_factory_;
 935
 936   DISALLOW_COPY_AND_ASSIGN(PepperPluginInstanceImpl);
 937 };
 938
 939 }  // namespace content
 940
 941 #endif  // CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_