Revert 98767 - Reimplement the Pepper fullscreen API to use webkitRequestFullScreen and friends.

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"
@@ skipping 34 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/skia_util.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/event_conversion.h"
+#include "webkit/plugins/ppapi/fullscreen_container.h"
 #include "webkit/plugins/ppapi/message_channel.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
 #include "webkit/plugins/ppapi/plugin_delegate.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/plugin_object.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_3d_impl.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
 #include "webkit/plugins/ppapi/ppb_surface_3d_impl.h"
@@ skipping 160 matching lines @@
       plugin_private_interface_(NULL),
       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),
-      desired_fullscreen_state_(false),
+      fullscreen_container_(NULL),
       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 23 matching lines @@
 // account that the plugin may use Var to remove the <embed> from the DOM, which
 // will make the WebPluginImpl drop its reference, usually the last one. If a
 // method needs to access a member of the instance after the call has returned,
 // then it needs to keep its own reference on the stack.
 
 void PluginInstance::Delete() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   instance_interface_->DidDestroy(pp_instance());
 
+  if (fullscreen_container_) {
+    fullscreen_container_->Destroy();
+    fullscreen_container_ = NULL;
+  }
   container_ = NULL;
 }
 
 void PluginInstance::Paint(WebCanvas* canvas,
                            const gfx::Rect& plugin_rect,
                            const gfx::Rect& paint_rect) {
   if (module()->is_crashed()) {
     // Crashed plugin painting.
     if (!sad_plugin_)  // Lazily initialize bitmap.
       sad_plugin_ = delegate_->GetSadPluginBitmap();
     if (sad_plugin_)
       webkit::PaintSadPlugin(canvas, plugin_rect, *sad_plugin_);
     return;
   }
 
   if (GetBoundGraphics2D())
     GetBoundGraphics2D()->Paint(canvas, plugin_rect, paint_rect);
 }
 
 void PluginInstance::InvalidateRect(const gfx::Rect& rect) {
-  if (!container_ || position_.IsEmpty())
-    return;  // Nothing to do.
-  if (rect.IsEmpty())
-    container_->invalidate();
-  else
-    container_->invalidateRect(rect);
+  if (fullscreen_container_) {
+    if (rect.IsEmpty())
+      fullscreen_container_->Invalidate();
+    else
+      fullscreen_container_->InvalidateRect(rect);
+  } else {
+    if (!container_ || position_.IsEmpty())
+      return;  // Nothing to do.
+    if (rect.IsEmpty())
+      container_->invalidate();
+    else
+      container_->invalidateRect(rect);
+  }
 }
 
 void PluginInstance::ScrollRect(int dx, int dy, const gfx::Rect& rect) {
-  if (full_frame_) {
-    container_->scrollRect(dx, dy, rect);
+  if (fullscreen_container_) {
+    fullscreen_container_->ScrollRect(dx, dy, rect);
   } else {
-    // Can't do optimized scrolling since there could be other elements on top
-    // of us.
-    InvalidateRect(rect);
+    if (full_frame_) {
+      container_->scrollRect(dx, dy, rect);
+    } else {
+      // Can't do optimized scrolling since there could be other elements on top
+      // of us.
+      InvalidateRect(rect);
+    }
   }
 }
 
 unsigned PluginInstance::GetBackingTextureId() {
   if (GetBoundGraphics3D())
     return GetBoundGraphics3D()->GetBackingTextureId();
   else if (GetBoundSurface3D())
     return GetBoundSurface3D()->GetBackingTextureId();
 
   return 0;
 }
 
 void PluginInstance::CommitBackingTexture() {
-  container_->commitBackingTexture();
+  if (fullscreen_container_)
+    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, false);
   bound_graphics_ = NULL;
   InvalidateRect(gfx::Rect());
@@ skipping 141 matching lines @@
 
   // If the plugin supports the private instance interface, try to retrieve its
   // instance object.
   if (LoadPrivateInterface())
     return plugin_private_interface_->GetInstanceObject(pp_instance());
   return PP_MakeUndefined();
 }
 
 void PluginInstance::ViewChanged(const gfx::Rect& position,
                                  const gfx::Rect& clip) {
-  fullscreen_ = desired_fullscreen_state_;
+  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 240 matching lines @@
   }
 
   return !!plugin_zoom_interface_;
 }
 
 bool PluginInstance::PluginHasFocus() const {
   return has_webkit_focus_ && has_content_area_focus_;
 }
 
 void PluginInstance::ReportGeometry() {
-  if (container_)
+  // 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 (!LoadPrintInterface())
     return false;
   uint32_t supported_formats =
@@ skipping 98 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::IsFullscreenOrPending() {
-  return desired_fullscreen_state_;
+  return fullscreen_container_ != NULL;
 }
 
 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;
 
-  desired_fullscreen_state_ = fullscreen;
-  if (fullscreen)
-    container_->element().requestFullScreen();
-  else
-    container_->element().document().cancelFullScreen();
-  if (!delay_report) {
-    ReportGeometry();
+  BindGraphics(pp_instance(), 0);
+  VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
+  if (fullscreen) {
+    DCHECK(!fullscreen_container_);
+    fullscreen_container_ = delegate_->CreateFullscreenContainer(this);
   } else {
-    MessageLoop::current()->PostTask(
+    DCHECK(fullscreen_container_);
+    fullscreen_container_->Destroy();
+    fullscreen_container_ = NULL;
+    fullscreen_ = false;
+    if (!delay_report) {
+      ReportGeometry();
+    } else {
+      MessageLoop::current()->PostTask(
           FROM_HERE, NewRunnableMethod(this, &PluginInstance::ReportGeometry));
+    }
   }
 }
 
 int32_t PluginInstance::Navigate(PPB_URLRequestInfo_Impl* request,
                                  const char* target,
                                  bool from_user_action) {
   if (!container_)
     return PP_ERROR_FAILED;
 
   WebDocument document = container_->element().document();
@@ skipping 26 matching lines @@
   if (web_request.httpMethod() != "GET" &&
       web_request.httpMethod() != "POST")
     return PP_ERROR_BADARGUMENT;
 
   WebString target_str = WebString::fromUTF8(target);
   container_->loadFrameRequest(web_request, target_str, false, NULL);
   return PP_OK;
 }
 
 PluginDelegate::PlatformContext3D* PluginInstance::CreateContext3D() {
-  return delegate_->CreateContext3D();
+  if (fullscreen_container_)
+    return fullscreen_container_->CreateContext3D();
+  else
+    return delegate_->CreateContext3D();
 }
 
 bool PluginInstance::PrintPDFOutput(PP_Resource print_output,
                                     WebKit::WebCanvas* canvas) {
   ::ppapi::thunk::EnterResourceNoLock<PPB_Buffer_API> enter(print_output, true);
   if (enter.failed())
     return false;
 
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size()) {
@@ skipping 249 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.
+  //
+  // 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_)
+    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 25 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_)
+    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() ?
       static_cast<PPB_Surface3D_Impl*>(enter_surface_3d.object()) : NULL;
 
@@ skipping 167 matching lines @@
 void PluginInstance::PostMessage(PP_Instance instance, PP_Var message) {
   message_channel_->PostMessageToJavaScript(message);
 }
 
 void PluginInstance::SubscribeToPolicyUpdates(PP_Instance instance) {
   delegate()->SubscribeToPolicyUpdates(this);
 }
 
 void PluginInstance::DoSetCursor(WebCursorInfo* cursor) {
   cursor_.reset(cursor);
+  if (fullscreen_container_)
+    fullscreen_container_->DidChangeCursor(*cursor);
 }
 
 }  // namespace ppapi
 }  // namespace webkit