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