Add fullscreen support to Pepper.

webkit/glue/plugins/pepper_plugin_instance.cc

 // Copyright (c) 2010 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/glue/plugins/pepper_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/histogram.h"
 #if defined(OS_MACOSX)
 #include "base/mac_util.h"
 #include "base/scoped_cftyperef.h"
 #endif
 #include "base/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "gfx/rect.h"
 #if defined(OS_WIN)
 #include "gfx/codec/jpeg_codec.h"
 #include "gfx/gdi_util.h"
 #endif
 #include "gfx/skia_util.h"
 #include "printing/native_metafile.h"
 #include "printing/units.h"
 #include "skia/ext/vector_platform_device.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/ppapi/c/dev/ppb_find_dev.h"
+#include "third_party/ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "third_party/ppapi/c/dev/ppp_find_dev.h"
 #include "third_party/ppapi/c/dev/ppp_zoom_dev.h"
 #include "third_party/ppapi/c/pp_event.h"
 #include "third_party/ppapi/c/pp_instance.h"
 #include "third_party/ppapi/c/pp_rect.h"
 #include "third_party/ppapi/c/pp_resource.h"
 #include "third_party/ppapi/c/pp_var.h"
 #include "third_party/ppapi/c/ppb_core.h"
 #include "third_party/ppapi/c/ppb_instance.h"
 #include "third_party/ppapi/c/ppp_instance.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebRect.h"
 #include "webkit/glue/plugins/pepper_buffer.h"
 #include "webkit/glue/plugins/pepper_graphics_2d.h"
 #include "webkit/glue/plugins/pepper_event_conversion.h"
+#include "webkit/glue/plugins/pepper_fullscreen_container.h"
 #include "webkit/glue/plugins/pepper_image_data.h"
 #include "webkit/glue/plugins/pepper_plugin_delegate.h"
 #include "webkit/glue/plugins/pepper_plugin_module.h"
 #include "webkit/glue/plugins/pepper_string.h"
 #include "webkit/glue/plugins/pepper_url_loader.h"
 #include "webkit/glue/plugins/pepper_var.h"
 
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebCursorInfo;
@@ skipping 143 matching lines @@
   DCHECK_NE(instance->find_identifier(), -1);
   instance->delegate()->DidChangeSelectedFindResult(
       instance->find_identifier(), index);
 }
 
 const PPB_Find_Dev ppb_find = {
   &NumberOfFindResultsChanged,
   &SelectedFindResultChanged,
 };
 
+bool IsFullscreen(PP_Instance instance_id) {
+  PluginInstance* instance = PluginInstance::FromPPInstance(instance_id);
+  if (!instance)
+    return false;
+  return instance->IsFullscreen();
+}
+
+bool SetFullscreen(PP_Instance instance_id, bool fullscreen) {
+  PluginInstance* instance = PluginInstance::FromPPInstance(instance_id);
+  if (!instance)
+    return false;
+  return instance->SetFullscreen(fullscreen);
+}
+
+const PPB_Fullscreen_Dev ppb_fullscreen = {
+  &IsFullscreen,
+  &SetFullscreen,
+};
+
 }  // namespace
 
 PluginInstance::PluginInstance(PluginDelegate* delegate,
                                PluginModule* module,
                                const PPP_Instance* instance_interface)
     : delegate_(delegate),
       module_(module),
       instance_interface_(instance_interface),
       container_(NULL),
       full_frame_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
       plugin_zoom_interface_(NULL),
 #if defined (OS_LINUX)
       num_pages_(0),
       pdf_output_done_(false),
 #endif  // defined (OS_LINUX)
       plugin_print_interface_(NULL),
-      plugin_graphics_3d_interface_(NULL) {
+      plugin_graphics_3d_interface_(NULL),
+      fullscreen_container_(NULL) {
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
 }
 
 PluginInstance::~PluginInstance() {
   delegate_->InstanceDeleted(this);
   module_->InstanceDeleted(this);
 }
 
 // static
 const PPB_Instance* PluginInstance::GetInterface() {
   return &ppb_instance;
 }
 
 // static
 PluginInstance* PluginInstance::FromPPInstance(PP_Instance instance) {
   return reinterpret_cast<PluginInstance*>(instance);
 }
 
 // static
 const PPB_Find_Dev* PluginInstance::GetFindInterface() {
   return &ppb_find;
 }
 
+// static
+const PPB_Fullscreen_Dev* PluginInstance::GetFullscreenInterface() {
+  return &ppb_fullscreen;
+}
+
 PP_Instance PluginInstance::GetPPInstance() {
   return reinterpret_cast<intptr_t>(this);
 }
 
 void PluginInstance::Paint(WebCanvas* canvas,
                            const gfx::Rect& plugin_rect,
                            const gfx::Rect& paint_rect) {
   if (bound_graphics_2d_)
     bound_graphics_2d_->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);
+  }
 }
 
 PP_Var PluginInstance::GetWindowObject() {
   if (!container_)
     return PP_MakeVoid();
 
   WebFrame* frame = container_->element().document().frame();
   if (!frame)
     return PP_MakeVoid();
 
@@ skipping 89 matching lines @@
   }
 
   PP_Var ret = Var::NPVariantToPPVar(module_, &result);
   WebBindings::releaseVariantValue(&result);
   return ret;
 }
 
 void PluginInstance::Delete() {
   instance_interface_->Delete(GetPPInstance());
 
+  if (fullscreen_container_) {
+    fullscreen_container_->Destroy();
+    fullscreen_container_ = NULL;
+  }
   container_ = NULL;
 }
 
 bool PluginInstance::Initialize(WebPluginContainer* container,
                                 const std::vector<std::string>& arg_names,
                                 const std::vector<std::string>& arg_values,
                                 bool full_frame) {
   container_ = container;
   full_frame_ = full_frame;
 
@@ skipping 241 matching lines @@
 void PluginInstance::Graphics3DContextLost() {
   if (!plugin_graphics_3d_interface_) {
     plugin_graphics_3d_interface_ =
         reinterpret_cast<const PPP_Graphics3D_Dev*>(module_->GetPluginInterface(
             PPP_GRAPHICS_3D_DEV_INTERFACE));
   }
   if (plugin_graphics_3d_interface_)
     plugin_graphics_3d_interface_->Graphics3DContextLost(GetPPInstance());
 }
 
+bool PluginInstance::IsFullscreen() {
+  return fullscreen_container_ != NULL;
+}
+
+bool PluginInstance::SetFullscreen(bool fullscreen) {
+  bool is_fullscreen = (fullscreen_container_ != NULL);
+  if (fullscreen == is_fullscreen)
+    return true;
+  LOG(INFO) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
+  if (fullscreen) {
+    fullscreen_container_ = delegate_->CreateFullscreenContainer(this);
+  } else {
+    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();
+    }
+  }
+  return true;
+}
+
 bool PluginInstance::PrintPDFOutput(PP_Resource print_output,
                                     WebKit::WebCanvas* canvas) {
   scoped_refptr<Buffer> buffer(Resource::GetAs<Buffer>(print_output));
   if (!buffer.get() || !buffer->is_mapped() || !buffer->size()) {
     NOTREACHED();
     return false;
   }
 #if defined(OS_WIN)
   // For Windows, we need the PDF DLL to render the output PDF to a DC.
   HMODULE pdf_module = GetModuleHandle(L"pdf.dll");
@@ skipping 207 matching lines @@
   bounds.size.width = dest_rect.width();
   bounds.size.height = dest_rect.height();
 
   CGContextDrawImage(canvas, bounds, image);
   CGContextRestoreGState(canvas);
 }
 #endif  // defined(OS_MACOSX)
 
 
 }  // namespace pepper