Clarify/fix fullscreen semantics, and add GetScreenSize

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/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_ptr.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_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_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"
@@ skipping 222 matching lines @@
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return PP_FALSE;
   return BoolToPPBool(instance->IsFullscreen());
 }
 
 PP_Bool SetFullscreen(PP_Instance instance_id, PP_Bool fullscreen) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return PP_FALSE;
-  return BoolToPPBool(instance->SetFullscreen(PPBoolToBool(fullscreen)));
+  instance->SetFullscreen(PPBoolToBool(fullscreen), true);
+  return PP_TRUE;
 }
 
+PP_Bool GetScreenSize(PP_Instance instance_id, PP_Size* size) {
+  PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
+  if (!instance || !size)
+    return PP_FALSE;
+  gfx::Size screen_size = instance->delegate()->GetScreenSize();
+  *size = PP_MakeSize(screen_size.width(), screen_size.height());
+  return PP_TRUE;
+}
+
+
 const PPB_Fullscreen_Dev ppb_fullscreen = {
   &IsFullscreen,
   &SetFullscreen,
+  &GetScreenSize
 };
 
 void ZoomChanged(PP_Instance instance_id, double factor) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return;
 
   // We only want to tell the page to change its zoom if the whole page is the
   // plugin.  If we're in an iframe, then don't do anything.
   if (!instance->IsFullPagePlugin())
@@ skipping 48 matching lines @@
       plugin_find_interface_(NULL),
       plugin_pdf_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_zoom_interface_(NULL),
 #if defined(OS_LINUX)
       canvas_(NULL),
 #endif  // defined(OS_LINUX)
       plugin_print_interface_(NULL),
       plugin_graphics_3d_interface_(NULL),
       always_on_top_(false),
-      fullscreen_container_(NULL) {
+      fullscreen_container_(NULL),
+      fullscreen_(false) {
   pp_instance_ = ResourceTracker::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
 }
 
 PluginInstance::~PluginInstance() {
   // Free all the plugin objects. This will automatically clear the back-
@@ skipping 91 matching lines @@
     fullscreen_container_->Invalidate();
   else
     container_->commitBackingTexture();
 }
 
 void PluginInstance::InstanceCrashed() {
   // Force free all resources and vars.
   ResourceTracker::Get()->InstanceCrashed(pp_instance());
 
   // Free any associated graphics.
-  SetFullscreen(false);
+  SetFullscreen(false, false);
   bound_graphics_ = NULL;
   InvalidateRect(gfx::Rect());
 
   // TODO(brettw) show a crashed plugin screen.
 }
 
 PP_Var PluginInstance::GetWindowObject() {
   if (!container_)
     return PP_MakeUndefined();
 
@@ skipping 25 matching lines @@
     bound_graphics_ = NULL;
     return true;
   }
 
   scoped_refptr<PPB_Graphics2D_Impl> graphics_2d =
       Resource::GetAs<PPB_Graphics2D_Impl>(graphics_id);
   scoped_refptr<PPB_Surface3D_Impl> graphics_3d =
       Resource::GetAs<PPB_Surface3D_Impl>(graphics_id);
 
   if (graphics_2d) {
+    // Refuse to bind if we're transitioning to fullscreen.
+    if (fullscreen_container_ && !fullscreen_)
+      return false;
     if (!graphics_2d->BindToInstance(this))
       return false;  // Can't bind to more than one instance.
 
     // See http://crbug.com/49403: this can be further optimized by keeping the
     // old device around and painting from it.
     if (bound_graphics_2d()) {
       // Start the new image with the content of the old image until the plugin
       // repaints.
       // Use ImageDataAutoMapper to ensure the image data is valid.
       ImageDataAutoMapper mapper(bound_graphics_2d()->image_data());
       if (!mapper.is_valid())
         return false;
       const SkBitmap* old_backing_bitmap =
           bound_graphics_2d()->image_data()->GetMappedBitmap();
       SkRect old_size = SkRect::MakeWH(
           SkScalar(static_cast<float>(old_backing_bitmap->width())),
           SkScalar(static_cast<float>(old_backing_bitmap->height())));
 
       SkCanvas canvas(*graphics_2d->image_data()->GetMappedBitmap());
       canvas.drawBitmap(*old_backing_bitmap, 0, 0);
 
       // Fill in any extra space with white.
       canvas.clipRect(old_size, SkRegion::kDifference_Op);
       canvas.drawARGB(255, 255, 255, 255);
     }
 
     bound_graphics_ = graphics_2d;
     // BindToInstance will have invalidated the plugin if necessary.
   } else if (graphics_3d) {
+    // Refuse to bind if we're transitioning to fullscreen.
+    if (fullscreen_container_ && !fullscreen_)
+      return false;
     // Make sure graphics can only be bound to the instance it is
     // associated with.
     if (graphics_3d->instance() != this)
       return false;
     if (!graphics_3d->BindToInstance(true))
       return false;
 
     bound_graphics_ = graphics_3d;
   }
 
@@ skipping 107 matching lines @@
     *cursor_info = *cursor_;
   return rv;
 }
 
 PP_Var PluginInstance::GetInstanceObject() {
   return instance_interface_->GetInstanceObject(pp_instance());
 }
 
 void PluginInstance::ViewChanged(const gfx::Rect& position,
                                  const gfx::Rect& clip) {
+  fullscreen_ = (fullscreen_container_ != NULL);
   position_ = position;
 
   if (clip.IsEmpty()) {
     // WebKit can give weird (x,y) positions for empty clip rects (since the
     // position technically doesn't matter). But we want to make these
     // consistent since this is given to the plugin, so force everything to 0
     // in the "everything is clipped" case.
     clip_ = gfx::Rect();
   } else {
     clip_ = clip;
@@ skipping 183 matching lines @@
             PPP_ZOOM_DEV_INTERFACE));
   }
 
   return !!plugin_zoom_interface_;
 }
 
 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_)
+    container_->reportGeometry();
+}
+
 bool PluginInstance::GetPreferredPrintOutputFormat(
     PP_PrintOutputFormat_Dev* format) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!plugin_print_interface_) {
     plugin_print_interface_ =
         reinterpret_cast<const PPP_Printing_Dev*>(module_->GetPluginInterface(
             PPP_PRINTING_DEV_INTERFACE));
   }
   if (!plugin_print_interface_)
@@ skipping 108 matching lines @@
   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::IsFullscreen() {
+  return fullscreen_;
+}
+
+bool PluginInstance::IsFullscreenOrPending() {
   return fullscreen_container_ != NULL;
 }
 
-bool PluginInstance::SetFullscreen(bool fullscreen) {
+void PluginInstance::SetFullscreen(bool fullscreen, bool delay_report) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
-  bool is_fullscreen = (fullscreen_container_ != NULL);
-  if (fullscreen == is_fullscreen)
-    return true;
+
+  // 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;
+
+  BindGraphics(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;
-    // TODO(piman): currently the fullscreen container resizes the plugin to the
-    // fullscreen size so we need to reset the size here. Eventually it will
-    // transparently scale and this won't be necessary.
-    if (container_) {
-      container_->reportGeometry();
-      container_->invalidate();
+    fullscreen_ = false;
+    if (!delay_report) {
+      ReportGeometry();
+    } else {
+      MessageLoop::current()->PostTask(
+          FROM_HERE, NewRunnableMethod(this, &PluginInstance::ReportGeometry));
     }
   }
-  return true;
 }
 
 bool PluginInstance::NavigateToURL(const char* url, const char* target) {
   if (!url || !target || !container_)
     return false;
 
   WebDocument document = container_->element().document();
   GURL complete_url = document.completeURL(WebString::fromUTF8(url));
   // Don't try to deal with the security issues of javascript.
   if (complete_url.SchemeIs("javascript"))
@@ skipping 295 matching lines @@
   return found->second;
 }
 
 bool PluginInstance::IsFullPagePlugin() const {
   WebFrame* frame = container()->element().document().frame();
   return frame->view()->mainFrame()->document().isPluginDocument();
 }
 
 }  // namespace ppapi
 }  // namespace webkit