Android: Add support for CompositorFrame swaps

content/browser/renderer_host/render_widget_host_view_android.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/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
+#include "cc/compositor_frame.h"
+#include "cc/compositor_frame_ack.h"
 #include "cc/layer.h"
 #include "cc/texture_layer.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
 #include "content/browser/renderer_host/image_transport_factory_android.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/surface_texture_transport_client_android.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebExternalTextureLayer.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "webkit/compositor_bindings/web_compositor_support_impl.h"
 
 namespace content {
 
+namespace {
+
+void InsertSyncPointAndAckForGpu(
+    int gpu_host_id, int route_id, const std::string& return_mailbox) {
+  uint32 sync_point =
+      ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
+  AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
+  ack_params.mailbox_name = return_mailbox;
+  ack_params.sync_point = sync_point;
+  RenderWidgetHostImpl::AcknowledgeBufferPresent(
+      route_id, gpu_host_id, ack_params);
+}
+
+void InsertSyncPointAndAckForCompositor(
+    int renderer_host_id,
+    int route_id,
+    const gpu::Mailbox& return_mailbox,
+    const gfx::Size return_size) {
+  cc::CompositorFrameAck ack;
+  ack.gl_frame_data.reset(new cc::GLFrameData());
+  if (!return_mailbox.IsZero()) {
+    ack.gl_frame_data->mailbox = return_mailbox;
+    ack.gl_frame_data->size = return_size;
+    ack.gl_frame_data->sync_point =
+        ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
+  }
+  RenderWidgetHostImpl::SendSwapCompositorFrameAck(
+      route_id, renderer_host_id, ack);
+}
+
+}  // anonymous namespace
+
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       is_layer_attached_(true),
       content_view_core_(NULL),
       ime_adapter_android_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       cached_background_color_(SK_ColorWHITE),
       texture_id_in_layer_(0) {
   if (CompositorImpl::UsesDirectGL()) {
@@ skipping 387 matching lines @@
     const gfx::Rect& target_rect, const SkBitmap& zoomed_bitmap) {
   if (!content_view_core_)
     return;
 
   content_view_core_->ShowDisambiguationPopup(target_rect, zoomed_bitmap);
 }
 
 void RenderWidgetHostViewAndroid::OnAcceleratedCompositingStateChange() {
 }
 
+void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
+    const cc::CompositorFrame& frame) {
+  if (!frame.gl_frame_data || frame.gl_frame_data->mailbox.IsZero())
+    return;
+
+  base::Closure callback = base::Bind(&InsertSyncPointAndAckForCompositor,
+                                      host_->GetProcess()->GetID(),
+                                      host_->GetRoutingID(),
+                                      current_mailbox_,
+                                      texture_size_in_layer_);
+  ImageTransportFactoryAndroid::GetInstance()->WaitSyncPoint(
+      frame.gl_frame_data->sync_point);
+  BuffersSwapped(
+      frame.gl_frame_data->mailbox, frame.gl_frame_data->size, callback);
+
+}
+
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
+  if (params.mailbox_name.empty())
+    return;
+
+  std::string return_mailbox;
+  if (!current_mailbox_.IsZero()) {
+    return_mailbox.assign(
+        reinterpret_cast<const char*>(current_mailbox_.name),
+        sizeof(current_mailbox_.name));
+  }
+
+  base::Closure callback = base::Bind(&InsertSyncPointAndAckForGpu,
+                                      gpu_host_id, params.route_id,
+                                      return_mailbox);
+
+  gpu::Mailbox mailbox;
+  std::copy(params.mailbox_name.data(),
+            params.mailbox_name.data() + params.mailbox_name.length(),
+            reinterpret_cast<char*>(mailbox.name));
+
+  BuffersSwapped(mailbox, params.size, callback);
+}
+
+void RenderWidgetHostViewAndroid::BuffersSwapped(
+    const gpu::Mailbox& mailbox,
+    const gfx::Size size,
+    const base::Closure& ack_callback) {
   ImageTransportFactoryAndroid* factory =
       ImageTransportFactoryAndroid::GetInstance();
 
-  if (params.mailbox_name.empty())
-    return;
-
   // TODO(sievers): When running the impl thread in the browser we
   // need to delay the ACK until after commit and use more than a single
   // texture.
   DCHECK(!CompositorImpl::IsThreadingEnabled());
 
   if (texture_id_in_layer_) {
-    DCHECK(!current_mailbox_name_.empty());
+    DCHECK(!current_mailbox_.IsZero());
     ImageTransportFactoryAndroid::GetInstance()->ReleaseTexture(
-        texture_id_in_layer_,
-        reinterpret_cast<const signed char*>(
-            current_mailbox_name_.data()));
+        texture_id_in_layer_, current_mailbox_.name);
   } else {
     texture_id_in_layer_ = factory->CreateTexture();
     texture_layer_->setTextureId(texture_id_in_layer_);
   }
 
   ImageTransportFactoryAndroid::GetInstance()->AcquireTexture(
-      texture_id_in_layer_,
-      reinterpret_cast<const signed char*>(
-          params.mailbox_name.data()));
+      texture_id_in_layer_, mailbox.name);
 
   // We need to tell ContentViewCore about the new frame before calling
   // setNeedsDisplay() below so that it has the needed information schedule the
   // next compositor frame.
   if (content_view_core_)
     content_view_core_->DidProduceRendererFrame();
 
   texture_layer_->setNeedsDisplay();
-  texture_layer_->setBounds(params.size);
-  texture_size_in_layer_ = params.size;
-
-  uint32 sync_point =
-      ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
-
-  AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
-  ack_params.mailbox_name = current_mailbox_name_;
-  ack_params.sync_point = sync_point;
-   RenderWidgetHostImpl::AcknowledgeBufferPresent(
-      params.route_id, gpu_host_id, ack_params);
-  current_mailbox_name_ = params.mailbox_name;
+  texture_layer_->setBounds(size);
+  texture_size_in_layer_ = size;
+  current_mailbox_ = mailbox;
+  ack_callback.Run();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceRelease() {
   // This tells us we should free the frontbuffer.
   if (texture_id_in_layer_) {
     texture_layer_->setTextureId(0);
     ImageTransportFactoryAndroid::GetInstance()->DeleteTexture(
         texture_id_in_layer_);
     texture_id_in_layer_ = 0;
-    current_mailbox_name_.clear();
+    current_mailbox_ = gpu::Mailbox();
   }
 }
 
 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   NOTREACHED();
   return false;
 }
 
 void RenderWidgetHostViewAndroid::GetScreenInfo(WebKit::WebScreenInfo* result) {
@@ skipping 154 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content