Make fullscreen pepper flash create a texture layer with software compositor

content/renderer/pepper/pepper_graphics_2d_host.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_graphics_2d_host.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "cc/resources/texture_mailbox.h"
+#include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/common.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/host/dispatch_host_message.h"
@@ skipping 159 matching lines @@
                                            PP_Instance instance,
                                            PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       renderer_ppapi_host_(host),
       bound_instance_(NULL),
       need_flush_ack_(false),
       offscreen_flush_pending_(false),
       is_always_opaque_(false),
       scale_(1.0f),
       weak_ptr_factory_(this),
-      is_running_in_process_(host->IsRunningInProcess()) {
-}
+      is_running_in_process_(host->IsRunningInProcess()),
+      texture_mailbox_modified_(true) {}
 
 PepperGraphics2DHost::~PepperGraphics2DHost() {
   // Unbind from the instance when destroyed if we're still bound.
   if (bound_instance_)
     bound_instance_->BindGraphics(bound_instance_->pp_instance(), 0);
 }
 
 bool PepperGraphics2DHost::Init(int width, int height, bool is_always_opaque) {
   // The underlying PPB_ImageData_Impl will validate the dimensions.
   image_data_ = new PPB_ImageData_Impl(pp_instance(),
@@ skipping 103 matching lines @@
     // When the device is detached, we'll not get any more paint callbacks so
     // we need to clear the list, but we still want to issue any pending
     // callbacks to the plugin.
     if (need_flush_ack_)
       ScheduleOffscreenFlushAck();
   } else {
     // Devices being replaced, redraw the plugin.
     new_instance->InvalidateRect(gfx::Rect());
   }
 
+  texture_mailbox_modified_ = true;
+
   bound_instance_ = new_instance;
   return true;
 }
 
 // The |backing_bitmap| must be clipped to the |plugin_rect| to avoid painting
 // outside the plugin area. This can happen if the plugin has been resized since
 // PaintImageData verified the image is within the plugin size.
 void PepperGraphics2DHost::Paint(WebKit::WebCanvas* canvas,
                                  const gfx::Rect& plugin_rect,
                                  const gfx::Rect& paint_rect) {
@@ skipping 219 matching lines @@
 }
 
 int32_t PepperGraphics2DHost::OnHostMsgReadImageData(
     ppapi::host::HostMessageContext* context,
     PP_Resource image,
     const PP_Point& top_left) {
   context->reply_msg = PpapiPluginMsg_Graphics2D_ReadImageDataAck();
   return ReadImageData(image, &top_left) ? PP_OK : PP_ERROR_FAILED;
 }
 
+void ReleaseCallback(scoped_ptr<base::SharedMemory> memory,
+                     unsigned sync_point,
+                     bool lost_resource) {}
+
+bool PepperGraphics2DHost::PrepareTextureMailbox(cc::TextureMailbox* mailbox) {
+  if (!texture_mailbox_modified_)
+    return false;
+  // TODO(jbauman): Send image_data_ through mailbox to avoid copy.
+  gfx::Size pixel_image_size(image_data_->width(), image_data_->height());
+  int buffer_size = pixel_image_size.GetArea() * 4;
+  scoped_ptr<base::SharedMemory> memory =
+      RenderThread::Get()->HostAllocateSharedMemoryBuffer(buffer_size);
+  if (!memory || !memory->Map(buffer_size))
+    return false;
+  void* src = image_data_->Map();
+  memcpy(memory->memory(), src, buffer_size);
+  image_data_->Unmap();
+
+  base::SharedMemory* mem = memory.get();
+  *mailbox =
+      cc::TextureMailbox(mem,
+                         pixel_image_size,
+                         base::Bind(&ReleaseCallback, base::Passed(&memory)));
+  texture_mailbox_modified_ = false;
+  return true;
+}
+
+void PepperGraphics2DHost::AttachedToNewLayer() {
+  texture_mailbox_modified_ = true;
+}
+
 int32_t PepperGraphics2DHost::Flush(PP_Resource* old_image_data) {
   bool done_replace_contents = false;
   bool no_update_visible = true;
   bool is_plugin_visible = true;
   for (size_t i = 0; i < queued_operations_.size(); i++) {
     QueuedOperation& operation = queued_operations_[i];
     gfx::Rect op_rect;
     switch (operation.type) {
       case QueuedOperation::PAINT:
         ExecutePaintImageData(operation.paint_image.get(),
@@ skipping 45 matching lines @@
         no_update_visible = false;
 
       // Notify the plugin of the entire change (op_rect), even if it is
       // partially or completely off-screen.
       if (operation.type == QueuedOperation::SCROLL) {
         bound_instance_->ScrollRect(scroll_delta.x(), scroll_delta.y(),
                                     op_rect);
       } else {
         bound_instance_->InvalidateRect(op_rect);
       }
+      texture_mailbox_modified_ = true;
     }
   }
   queued_operations_.clear();
 
   if (!bound_instance_) {
     // As promised in the API, we always schedule callback when unbound.
     ScheduleOffscreenFlushAck();
   } else if (no_update_visible && is_plugin_visible &&
              bound_instance_->view_data().is_page_visible) {
     // There's nothing visible to invalidate so just schedule the callback to
@@ skipping 129 matching lines @@
     gfx::Point inverse_scaled_point =
         gfx::ToFlooredPoint(gfx::ScalePoint(*delta, inverse_scale));
     if (original_delta != inverse_scaled_point)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content