Make fullscreen pepper flash create a texture layer with software compositor

content/renderer/pepper/pepper_plugin_instance_impl.cc

 // Copyright (c) 2012 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 "content/renderer/pepper/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "cc/layers/texture_layer.h"
 #include "content/common/content_constants_internal.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/pepper/common.h"
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 #include "content/renderer/pepper/event_conversion.h"
 #include "content/renderer/pepper/fullscreen_container.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/host_dispatcher_wrapper.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/message_channel.h"
@@ skipping 584 matching lines @@
   if (bound_graphics_2d_platform_)
     bound_graphics_2d_platform_->Paint(canvas, plugin_rect, paint_rect);
 }
 
 void PepperPluginInstanceImpl::InvalidateRect(const gfx::Rect& rect) {
   if (fullscreen_container_) {
     if (rect.IsEmpty())
       fullscreen_container_->Invalidate();
     else
       fullscreen_container_->InvalidateRect(rect);
+    if (software_texture_layer_)
+      software_texture_layer_->SetNeedsDisplay();
   } else {
     if (!container_ ||
         view_data_.rect.size.width == 0 || view_data_.rect.size.height == 0)
       return;  // Nothing to do.
     if (rect.IsEmpty())
       container_->invalidate();
     else
       container_->invalidateRect(rect);
   }
 }
@@ skipping 1024 matching lines @@
     bool flash_fullscreen) {
   bool is_mouselock_pending = TrackedCallback::IsPending(lock_mouse_callback_);
 
   if (flash_fullscreen == flash_fullscreen_) {
     // Manually clear callback when fullscreen fails with mouselock pending.
     if (!flash_fullscreen && is_mouselock_pending)
       lock_mouse_callback_->Run(PP_ERROR_FAILED);
     return;
   }
 
-  PPB_Graphics3D_Impl* graphics_3d  = bound_graphics_3d_.get();
-  if (graphics_3d)
-    UpdateLayer();
+  UpdateLayer();
 
   bool old_plugin_focus = PluginHasFocus();
   flash_fullscreen_ = flash_fullscreen;
   if (is_mouselock_pending && !IsMouseLocked()) {
     if (!IsProcessingUserGesture() &&
         !module_->permissions().HasPermission(
             ppapi::PERMISSION_BYPASS_USER_GESTURE)) {
       lock_mouse_callback_->Run(PP_ERROR_NO_USER_GESTURE);
     } else {
       // Open a user gesture here so the Webkit user gesture checks will succeed
@@ skipping 120 matching lines @@
 void PepperPluginInstanceImpl::UpdateLayer() {
   if (!container_)
     return;
 
   gpu::Mailbox mailbox;
   if (bound_graphics_3d_.get()) {
     PlatformContext3D* context = bound_graphics_3d_->platform_context();
     context->GetBackingMailbox(&mailbox);
   }
   bool want_layer = !mailbox.IsZero();
+  bool want_2d_layer =
+      !!fullscreen_container_ && CommandLine::ForCurrentProcess()->HasSwitch(

[piman, 2013/09/05 00:19:43]

Should we do this in the !fullscreen case too? With paint and draw culling, it
might save some painting of the pixels underneath I think. But I may be missing
part of the tradeoff.

+                                     switches::kEnableSoftwareCompositing);
 
   if (want_layer == !!texture_layer_.get() &&
+      (want_layer || (want_2d_layer == !!software_texture_layer_.get())) &&
       layer_bound_to_fullscreen_ == !!fullscreen_container_)
     return;
 
-  if (texture_layer_.get()) {
+  if (texture_layer_ || software_texture_layer_) {
     if (!layer_bound_to_fullscreen_)
       container_->setWebLayer(NULL);
     else if (fullscreen_container_)
       fullscreen_container_->SetLayer(NULL);
     web_layer_.reset();
     texture_layer_ = NULL;
+    software_texture_layer_ = NULL;
   }
   if (want_layer) {
     DCHECK(bound_graphics_3d_.get());
     texture_layer_ = cc::TextureLayer::CreateForMailbox(NULL);
     web_layer_.reset(new webkit::WebLayerImpl(texture_layer_));
     if (fullscreen_container_) {
       fullscreen_container_->SetLayer(web_layer_.get());
       // Ignore transparency in fullscreen, since that's what Flash always
       // wants to do, and that lets it not recreate a context if
       // wmode=transparent was specified.
       texture_layer_->SetContentsOpaque(true);
     } else {
       container_->setWebLayer(web_layer_.get());
       texture_layer_->SetContentsOpaque(bound_graphics_3d_->IsOpaque());
     }
     texture_layer_->SetTextureMailbox(
         cc::TextureMailbox(mailbox, base::Bind(&IgnoreCallback), 0));
+  } else if (want_2d_layer) {
+    software_texture_layer_ = cc::TextureLayer::CreateForMailbox(this);
+    software_texture_layer_->SetContentsOpaque(true);
+    web_layer_.reset(new webkit::WebLayerImpl(software_texture_layer_));
+    fullscreen_container_->SetLayer(web_layer_.get());
+    software_texture_layer_->SetIsDrawable(true);
+    software_texture_layer_->SetFlipped(false);
   }
   layer_bound_to_fullscreen_ = !!fullscreen_container_;
 }
 
+unsigned PepperPluginInstanceImpl::PrepareTexture() {
+  return 0;
+}
+
+WebKit::WebGraphicsContext3D* PepperPluginInstanceImpl::Context3d() {
+  return NULL;
+}
+
+bool PepperPluginInstanceImpl::PrepareTextureMailbox(
+    cc::TextureMailbox* mailbox,
+    bool use_shared_memory) {
+  if (!bound_graphics_2d_platform_)
+    return false;
+  return bound_graphics_2d_platform_->PrepareTextureMailbox(mailbox);
+}
+
 void PepperPluginInstanceImpl::AddPluginObject(PluginObject* plugin_object) {
   DCHECK(live_plugin_objects_.find(plugin_object) ==
          live_plugin_objects_.end());
   live_plugin_objects_.insert(plugin_object);
 }
 
 void PepperPluginInstanceImpl::RemovePluginObject(PluginObject* plugin_object) {
   // Don't actually verify that the object is in the set since during module
   // deletion we'll be in the process of freeing them.
   live_plugin_objects_.erase(plugin_object);
@@ skipping 1052 matching lines @@
     // Running out-of-process. Initiate an IPC call to notify the plugin
     // process.
     ppapi::proxy::HostDispatcher* dispatcher =
         ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
     dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
         ppapi::API_ID_PPP_INSTANCE, pp_instance(), pending_host_id, data));
   }
 }
 
 }  // namespace content