Add PPB_Fullscreen;0.5.

webkit/plugins/ppapi/ppapi_plugin_instance.cc

 // 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.
 
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/dev/ppb_memory_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_policy_update_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
+#include "ppapi/c/ppb_fullscreen.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/private/ppb_instance_private.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/shared_impl/input_event_impl.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
@@ skipping 192 matching lines @@
       plugin_pdf_interface_(NULL),
       plugin_policy_updated_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_zoom_interface_(NULL),
       checked_for_plugin_input_event_interface_(false),
       checked_for_plugin_messaging_interface_(false),
       plugin_print_interface_(NULL),
       plugin_graphics_3d_interface_(NULL),
       always_on_top_(false),
       fullscreen_container_(NULL),
+      fullscreen_dev_(false),
+      desired_fullscreen_state_(false),
       fullscreen_(false),
       message_channel_(NULL),
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0) {
   pp_instance_ = ResourceTracker::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
@@ skipping 98 matching lines @@
   else
     container_->commitBackingTexture();
 }
 
 void PluginInstance::InstanceCrashed() {
   // Force free all resources and vars.
   ResourceTracker::Get()->InstanceCrashed(pp_instance());
 
   // Free any associated graphics.
   SetFullscreen(false, false);
+  SetFullscreen_Dev(false, false);
   bound_graphics_ = NULL;
   InvalidateRect(gfx::Rect());
 
   delegate()->PluginCrashed(this);
 }
 
 bool PluginInstance::SetCursor(PP_CursorType_Dev type,
                                PP_Resource custom_image,
                                const PP_Point* hot_spot) {
   if (type != PP_CURSORTYPE_CUSTOM) {
@@ skipping 148 matching lines @@
   if (!clip.IsEmpty())
     new_clip = clip;
 
   // Don't notify the plugin if we've already sent these same params before.
   if (sent_did_change_view_ && position == position_ && new_clip == clip_)
     return;
 
   sent_did_change_view_ = true;
   position_ = position;
   clip_ = new_clip;
-  fullscreen_ = (fullscreen_container_ != NULL);
+  fullscreen_ = desired_fullscreen_state_;
+  fullscreen_dev_ = (fullscreen_container_ != NULL);
 
   PP_Rect pp_position, pp_clip;
   RectToPPRect(position_, &pp_position);
   RectToPPRect(clip_, &pp_clip);
   instance_interface_->DidChangeView(pp_instance(), &pp_position, &pp_clip);
 }
 
 void PluginInstance::SetWebKitFocus(bool has_focus) {
   if (has_webkit_focus_ == has_focus)
     return;
@@ skipping 232 matching lines @@
 }
 
 bool PluginInstance::PluginHasFocus() const {
   return has_webkit_focus_ && has_content_area_focus_;
 }
 
 void PluginInstance::ReportGeometry() {
   // If this call was delayed, we may have transitioned back to fullscreen in
   // the mean time, so only report the geometry if we are actually in normal
   // mode.
-  if (container_ && !fullscreen_container_)
+  if (container_ && !fullscreen_container_ && !fullscreen_dev_)
     container_->reportGeometry();
 }
 
 bool PluginInstance::GetPreferredPrintOutputFormat(
     PP_PrintOutputFormat_Dev* format) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadPrintInterface())
     return false;
   uint32_t supported_formats =
@@ skipping 97 matching lines @@
   DCHECK(plugin_print_interface_);
   if (plugin_print_interface_)
     plugin_print_interface_->End(pp_instance());
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
 #if defined(OS_MACOSX)
   last_printed_page_ = NULL;
 #endif  // defined(OS_MACOSX)
 }
 
+bool PluginInstance::IsFullscreenOrPending_Dev() {
+  return fullscreen_container_ != NULL;
+}
+
 bool PluginInstance::IsFullscreenOrPending() {
-  return fullscreen_container_ != NULL;
+  return desired_fullscreen_state_;
 }
 
 void PluginInstance::SetFullscreen(bool fullscreen, bool delay_report) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
 
   // We check whether we are trying to switch to the state we're already going
   // to (i.e. if we're already switching to fullscreen but the fullscreen
   // container isn't ready yet, don't do anything more).
   if (fullscreen == IsFullscreenOrPending())
     return;
 
+  // Unbind current 2D or 3D graphics context.
+  BindGraphics(pp_instance(), 0);

[jeremya, 2011/09/09 17:45:35]

Is it necessary to unbind the graphics context here?

[polina, 2011/09/26 21:57:00]

That's what the interface documentation in the header says should happen and how
the old implementation works. This also seems to be consistent with not allowing
device binding during transitions.

That said, I do have a concern that this is inconsistent with what a user needs
to do on resize. No rebinding is necessary in that case, just a ResizeBuffers
call. I would be open to making this consistent. For example, we could unbind
and rebind for the user implicitly, so that he she only needs to resize to the
fullscreen in DidChangeView.

+
+  VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
+  desired_fullscreen_state_ = fullscreen;
+  if (fullscreen)
+    container_->element().requestFullScreen();
+  else
+    container_->element().document().cancelFullScreen();
+  if (!delay_report) {
+    ReportGeometry();
+  } else {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, NewRunnableMethod(this, &PluginInstance::ReportGeometry));
+  }
+}
+
+void PluginInstance::SetFullscreen_Dev(bool fullscreen, bool delay_report) {
+  // Keep a reference on the stack. See NOTE above.
+  scoped_refptr<PluginInstance> ref(this);
+
+  // We check whether we are trying to switch to the state we're already going
+  // to (i.e. if we're already switching to fullscreen but the fullscreen
+  // container isn't ready yet, don't do anything more).
+  if (fullscreen == IsFullscreenOrPending_Dev())
+    return;
+
+  // Unbind current 2D or 3D graphics context.
   BindGraphics(pp_instance(), 0);
   VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
   if (fullscreen) {
     DCHECK(!fullscreen_container_);
     fullscreen_container_ = delegate_->CreateFullscreenContainer(this);
   } else {
     DCHECK(fullscreen_container_);
     fullscreen_container_->Destroy();
     fullscreen_container_ = NULL;
-    fullscreen_ = false;
+    fullscreen_dev_ = false;
     if (!delay_report) {
       ReportGeometry();
     } else {
       MessageLoop::current()->PostTask(
           FROM_HERE, NewRunnableMethod(this, &PluginInstance::ReportGeometry));
     }
   }
 }
 
 int32_t PluginInstance::Navigate(PPB_URLRequestInfo_Impl* request,
@@ skipping 305 matching lines @@
 PPB_Surface3D_Impl* PluginInstance::GetBoundSurface3D() const {
   if (bound_graphics_.get() == NULL)
     return NULL;
 
   if (bound_graphics_->AsPPB_Surface3D_API())
     return static_cast<PPB_Surface3D_Impl*>(bound_graphics_.get());
   return NULL;
 }
 
 void PluginInstance::setBackingTextureId(unsigned int id) {
-  // If we have a full-screen container_ then the plugin is fullscreen,
-  // and the parent context is not the one for the browser page, but for the
-  // full-screen window, and so the parent texture ID doesn't correspond to
-  // anything in the page's context.
+  // If we have a fullscreen_container_ (under PPB_Fullscreen_Dev)
+  // or desired_fullscreen_state is true (under PPB_Fullscreen),
+  // then the plugin is fullscreen or transitioning to fullscreen
+  // and the parent context is not the one for the browser page,
+  // but for the fullscreen window, and so the parent texture ID
+  // doesn't correspond to anything in the page's context.
   //
   // TODO(alokp): It would be better at some point to have the equivalent
   // in the FullscreenContainer so that we don't need to poll
-  if (fullscreen_container_)
+  if (fullscreen_container_ || desired_fullscreen_state_)
     return;
 
   if (container_)
     container_->setBackingTextureId(id);
 }
 
 void PluginInstance::AddPluginObject(PluginObject* plugin_object) {
   DCHECK(live_plugin_objects_.find(plugin_object) ==
          live_plugin_objects_.end());
   live_plugin_objects_.insert(plugin_object);
@@ skipping 27 matching lines @@
     bound_graphics_ = NULL;
   }
 
   // Special-case clearing the current device.
   if (!device) {
     setBackingTextureId(0);
     InvalidateRect(gfx::Rect());
     return PP_TRUE;
   }
 
-  // Refuse to bind if we're transitioning to fullscreen.
-  if (fullscreen_container_ && !fullscreen_)
+  // Refuse to bind if we're transitioning to fullscreen with PPB_Fullscreen_Dev
+  // or to/from fullscreen with PPB_Fullscreen.
+  if ((fullscreen_container_ && !fullscreen_dev_) ||
+      desired_fullscreen_state_ != fullscreen_)
     return PP_FALSE;
 
   EnterResourceNoLock<PPB_Graphics2D_API> enter_2d(device, false);
   PPB_Graphics2D_Impl* graphics_2d = enter_2d.succeeded() ?
       static_cast<PPB_Graphics2D_Impl*>(enter_2d.object()) : NULL;
   EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
   PPB_Graphics3D_Impl* graphics_3d = enter_3d.succeeded() ?
       static_cast<PPB_Graphics3D_Impl*>(enter_3d.object()) : NULL;
   EnterResourceNoLock<PPB_Surface3D_API> enter_surface_3d(device, false);
   PPB_Surface3D_Impl* surface_3d = enter_surface_3d.succeeded() ?
@@ skipping 98 matching lines @@
 
   PP_Var ret = NPVariantToPPVar(this, &result);
   WebBindings::releaseVariantValue(&result);
   return ret;
 }
 
 PP_Bool PluginInstance::IsFullscreen(PP_Instance instance) {
   return PP_FromBool(fullscreen_);
 }
 
+PP_Bool PluginInstance::IsFullscreen_Dev(PP_Instance instance) {
+  return PP_FromBool(fullscreen_dev_);
+}
+
 PP_Bool PluginInstance::SetFullscreen(PP_Instance instance,
                                       PP_Bool fullscreen) {
   SetFullscreen(PP_ToBool(fullscreen), true);
   return PP_TRUE;
 }
 
+PP_Bool PluginInstance::SetFullscreen_Dev(PP_Instance instance,
+                                          PP_Bool fullscreen) {
+  SetFullscreen_Dev(PP_ToBool(fullscreen), true);
+  return PP_TRUE;
+}
+
 PP_Bool PluginInstance::GetScreenSize(PP_Instance instance, PP_Size* size) {
   gfx::Size screen_size = delegate()->GetScreenSize();
   *size = PP_MakeSize(screen_size.width(), screen_size.height());
   return PP_TRUE;
 }
 
+PP_Bool PluginInstance::GetScreenSize_Dev(PP_Instance instance, PP_Size* size) {
+  return GetScreenSize(instance, size);
+}
+
 int32_t PluginInstance::RequestInputEvents(PP_Instance instance,
                                            uint32_t event_classes) {
   input_event_mask_ |= event_classes;
   filtered_input_event_mask_ &= ~(event_classes);
   return ValidateRequestInputEvents(false, event_classes);
 }
 
 int32_t PluginInstance::RequestFilteringInputEvents(PP_Instance instance,
                                                     uint32_t event_classes) {
   filtered_input_event_mask_ |= event_classes;
@@ skipping 45 matching lines @@
 }
 
 void PluginInstance::DoSetCursor(WebCursorInfo* cursor) {
   cursor_.reset(cursor);
   if (fullscreen_container_)
     fullscreen_container_->DidChangeCursor(*cursor);
 }
 
 }  // namespace ppapi
 }  // namespace webkit