Add PPB_Fullscreen;0.5.

webkit/plugins/ppapi/ppapi_plugin_instance.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_H_
 #define WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 189 matching lines @@
   void SelectFindResult(bool forward);
   void StopFind();
 
   bool SupportsPrintInterface();
   int PrintBegin(const gfx::Rect& printable_area, int printer_dpi);
   bool PrintPage(int page_number, WebKit::WebCanvas* canvas);
   void PrintEnd();
 
   void Graphics3DContextLost();
 
+  // There are 2 implementations of the fullscreen interface. PPB_Fullscreen_Dev
+  // is used by Pepper Flash. PPB_Fullscreen is intended for other applications
+  // including NaCl. The two interface are mutually exclusive.
+
   // Implementation of PPB_Fullscreen_Dev.
 
   // Because going to fullscreen is asynchronous (but going out is not), there
   // are 3 states:
-  // - normal (fullscreen_container_ == NULL)
-  // - fullscreen pending (fullscreen_container_ != NULL, fullscreen_ == false)
-  // - fullscreen (fullscreen_container_ != NULL, fullscreen_ = true)
+  // - normal            : fullscreen_container_ == NULL
+  //                       fullscreen_dev_ == false
+  // - fullscreen pending: fullscreen_container_ != NULL
+  //                       fullscreen_dev_ == false
+  // - fullscreen        : fullscreen_container_ != NULL
+  //                       fullscreen_dev_ == true
   //
   // In normal state, events come from webkit and painting goes back to it.
   // In fullscreen state, events come from the fullscreen container, and
-  // painting goes back to it
+  // painting goes back to it.
   // In pending state, events from webkit are ignored, and as soon as we receive
   // events from the fullscreen container, we go to the fullscreen state.
+  bool IsFullscreenOrPending_Dev();
+
+  // Switches between fullscreen and normal mode. If |delay_report| is set to
+  // false, it may report the new state through DidChangeView immediately. If
+  // true, it will delay it. When called from the plugin, delay_report should be
+  // true to avoid re-entrancy.
+  void SetFullscreen_Dev(bool fullscreen, bool delay_report);
+
+  FullscreenContainer* fullscreen_container() const {
+    return fullscreen_container_;
+  }
+
+  // Implementation of PPB_Fullscreen.
+
+  // Because going to/from fullscreen is asynchronous, there are 4 states:
+  // - normal            : desired_fullscreen_state_ == false
+  //                       fullscreen_ == false
+  // - fullscreen pending: desired_fullscreen_state_ == true
+  //                       fullscreen_ == false
+  // - fullscreen        : desired_fullscreen_state_ == true
+  //                       fullscreen_ == true
+  // - normal pending    : desired_fullscreen_state_ = false
+  //                       fullscreen_ = true
   bool IsFullscreenOrPending();
 
   // Switches between fullscreen and normal mode. If |delay_report| is set to
   // false, it may report the new state through DidChangeView immediately. If
   // true, it will delay it. When called from the plugin, delay_report should be
   // true to avoid re-entrancy.
   void SetFullscreen(bool fullscreen, bool delay_report);
 
   // Implementation of PPB_Flash.
   int32_t Navigate(PPB_URLRequestInfo_Impl* request,
                    const char* target,
                    bool from_user_action);
 
   // Implementation of PPP_Messaging.
   void HandleMessage(PP_Var message);
 
   PluginDelegate::PlatformContext3D* CreateContext3D();
 
   // Returns true iff the plugin is a full-page plugin (i.e. not in an iframe or
   // embedded in a page).
   bool IsFullPagePlugin() const;
 
-  FullscreenContainer* fullscreen_container() const {
-    return fullscreen_container_;
-  }
-
   // FunctionGroupBase overrides.
   virtual ::ppapi::thunk::PPB_Instance_FunctionAPI* AsPPB_Instance_FunctionAPI()
       OVERRIDE;
 
-  // PPB_Instance_API implementation.
+  // PPB_Instance_FunctionAPI implementation.
   virtual PP_Bool BindGraphics(PP_Instance instance,
                                PP_Resource device) OVERRIDE;
   virtual PP_Bool IsFullFrame(PP_Instance instance) OVERRIDE;
   virtual PP_Var GetWindowObject(PP_Instance instance) OVERRIDE;
   virtual PP_Var GetOwnerElementObject(PP_Instance instance) OVERRIDE;
   virtual PP_Var ExecuteScript(PP_Instance instance,
                                PP_Var script,
                                PP_Var* exception) OVERRIDE;
   virtual PP_Bool IsFullscreen(PP_Instance instance) OVERRIDE;
+  virtual PP_Bool IsFullscreen_Dev(PP_Instance instance) OVERRIDE;
   virtual PP_Bool SetFullscreen(PP_Instance instance,
                                 PP_Bool fullscreen) OVERRIDE;
+  virtual PP_Bool SetFullscreen_Dev(PP_Instance instance,
+                                    PP_Bool fullscreen) OVERRIDE;
   virtual PP_Bool GetScreenSize(PP_Instance instance, PP_Size* size) OVERRIDE;
+  virtual PP_Bool GetScreenSize_Dev(PP_Instance instance, PP_Size* size)
+      OVERRIDE;
   virtual int32_t RequestInputEvents(PP_Instance instance,
                                      uint32_t event_classes) OVERRIDE;
   virtual int32_t RequestFilteringInputEvents(PP_Instance instance,
                                               uint32_t event_classes) OVERRIDE;
   virtual void ClearInputEventRequest(PP_Instance instance,
                                       uint32_t event_classes) OVERRIDE;
   virtual void ZoomChanged(PP_Instance instance, double factor) OVERRIDE;
   virtual void ZoomLimitsChanged(PP_Instance instance,
                                  double minimum_factor,
                                  double maximium_factor) OVERRIDE;
@@ skipping 158 matching lines @@
   // The plugin 3D interface.
   const PPP_Graphics3D* plugin_graphics_3d_interface_;
 
   // Contains the cursor if it's set by the plugin.
   scoped_ptr<WebKit::WebCursorInfo> cursor_;
 
   // Set to true if this plugin thinks it will always be on top. This allows us
   // to use a more optimized painting path in some cases.
   bool always_on_top_;
 
+  // Implementation of PPB_Fullscreen_Dev.
+
   // Plugin container for fullscreen mode. NULL if not in fullscreen mode. Note:
   // there is a transition state where fullscreen_container_ is non-NULL but
   // fullscreen_ is false (see above).
   FullscreenContainer* fullscreen_container_;
 
-  // True if we are in fullscreen mode. Note: it is false during the transition.
+  // True if we are in fullscreen mode. False if we are in normal mode or
+  // in transition to fullscreen.
+  bool fullscreen_dev_;
+
+  // Implementation of PPB_Fullscreen.
+
+  // Since entering fullscreen mode is an asynchronous operation, we set this
+  // variable to the desired state at the time we issue the fullscreen change
+  // request. The plugin will receive a DidChangeView event when it goes
+  // fullscreen.
+  bool desired_fullscreen_state_;
+
+  // True if we are in fullscreen mode. False if we are in normal mode.
+  // It reflects the previous state when in transition.
   bool fullscreen_;
 
   // The MessageChannel used to implement bidirectional postMessage for the
   // instance.
   scoped_ptr<MessageChannel> message_channel_;
 
   // Bitmap for crashed plugin. Lazily initialized, non-owning pointer.
   SkBitmap* sad_plugin_;
 
   typedef std::set<PluginObject*> PluginObjectSet;
   PluginObjectSet live_plugin_objects_;
 
   // Classes of events that the plugin has registered for, both for filtering
   // and not. The bits are PP_INPUTEVENT_CLASS_*.
   uint32_t input_event_mask_;
   uint32_t filtered_input_event_mask_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginInstance);
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_H_