Aura: Have ui::Layer implement WebKit::WebExternalTextureLayerClient

content/browser/renderer_host/render_widget_host_view_aura.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_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 534 matching lines @@
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
   current_surface_ = params_in_pixel.surface_handle;
   UpdateExternalTexture();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface.
     // Must still send the ACK.
-    InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id);
+    InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, compositor);

[piman, 2012/07/09 22:40:01]

compositor is NULL here. I don't think this works (it was broken before, but
this makes it more evident...)

[jonathan.backer, 2012/07/11 21:02:03]

Good catch. The right thing to do here is to return a 0 sync point. Then
TextureImageTransportSurface won't wait for it on the service side.

   } else {
     gfx::Size surface_size_in_pixel =
         image_transport_clients_[params_in_pixel.surface_handle]->size();
     gfx::Size surface_size = content::ConvertSizeToDIP(this,
                                                        surface_size_in_pixel);
     window_->SchedulePaintInRect(gfx::Rect(surface_size));
 
     if (!resize_locks_.empty()) {
       // If we are waiting for the resize, fast-track the ACK.
-      InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id);
+      compositor->AddDidCommitCallback(
+          base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
+                     params_in_pixel.route_id,
+                     gpu_host_id));
     } else {
       // Add sending an ACK to the list of things to do OnCompositingWillStart
       on_compositing_will_start_callbacks_.push_back(
           base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
-                     base::Unretained(this),
                      params_in_pixel.route_id,
                      gpu_host_id));
       if (!compositor->HasObserver(this))
         compositor->AddObserver(this);
     }
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
     int gpu_host_id) {
   current_surface_ = params_in_pixel.surface_handle;
   UpdateExternalTexture();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface
     // Must still send the ACK
-    InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id);
+    InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, compositor);
   } else {
     gfx::Size surface_size_in_pixel =
         image_transport_clients_[params_in_pixel.surface_handle]->size();
 
     // Co-ordinates come in OpenGL co-ordinate space.
     // We need to convert to layer space.
     gfx::Rect rect_to_paint = content::ConvertRectToDIP(this, gfx::Rect(
         params_in_pixel.x,
         surface_size_in_pixel.height() - params_in_pixel.y -
             params_in_pixel.height,
         params_in_pixel.width,
         params_in_pixel.height));
     window_->SchedulePaintInRect(rect_to_paint);
 
     if (!resize_locks_.empty()) {
       // If we are waiting for the resize, fast-track the ACK.
-      InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id);
+      compositor->AddDidCommitCallback(
+          base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
+                     params_in_pixel.route_id,
+                     gpu_host_id));
     } else {
       // Add sending an ACK to the list of things to do OnCompositingWillStart
       on_compositing_will_start_callbacks_.push_back(
           base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
-                     base::Unretained(this),
                      params_in_pixel.route_id,
                      gpu_host_id));
       if (!compositor->HasObserver(this))
         compositor->AddObserver(this);
     }
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
@@ skipping 587 matching lines @@
 
 void RenderWidgetHostViewAura::OnLostActive() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::CompositorObserver implementation:
 
 
 void RenderWidgetHostViewAura::OnCompositingWillStart(
     ui::Compositor* compositor) {
-  RunCompositingCallbacks();
+  RunCompositingCallbacks(compositor);
 }
 
 void RenderWidgetHostViewAura::OnCompositingStarted(
     ui::Compositor* compositor) {
   locks_pending_draw_.clear();
   compositor->RemoveObserver(this);
 }
 
 void RenderWidgetHostViewAura::OnCompositingEnded(ui::Compositor* compositor) {
 }
@@ skipping 127 matching lines @@
   gfx::Rect rect = window_->bounds();
   int border_x = rect.width() * kMouseLockBorderPercentage / 100;
   int border_y = rect.height() * kMouseLockBorderPercentage / 100;
 
   return global_mouse_position_.x() < rect.x() + border_x ||
       global_mouse_position_.x() > rect.right() - border_x ||
       global_mouse_position_.y() < rect.y() + border_y ||
       global_mouse_position_.y() > rect.bottom() - border_y;
 }
 
-void RenderWidgetHostViewAura::RunCompositingCallbacks() {
-  for (std::vector< base::Callback<void(void)> >::const_iterator
+void RenderWidgetHostViewAura::RunCompositingCallbacks(
+    ui::Compositor* compositor) {
+  for (std::vector< base::Callback<void(ui::Compositor*)> >::const_iterator
       it = on_compositing_will_start_callbacks_.begin();
       it != on_compositing_will_start_callbacks_.end(); ++it) {
-    it->Run();
+    it->Run(compositor);
   }
   on_compositing_will_start_callbacks_.clear();
 }
 
-void RenderWidgetHostViewAura::InsertSyncPointAndACK(int32 route_id,
-                                                     int gpu_host_id) {
+// static
+void RenderWidgetHostViewAura::InsertSyncPointAndACK(
+     int32 route_id, int gpu_host_id, ui::Compositor* compositor) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
-      route_id, gpu_host_id, factory->InsertSyncPoint(GetCompositor()));
+      route_id, gpu_host_id, factory->InsertSyncPoint(compositor));
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   // We are about to disconnect ourselves from the compositor, we need to issue
   // the callbacks now, because we won't get notified when the frame is done.
   // TODO(piman): this might in theory cause a race where the GPU process starts
   // drawing to the buffer we haven't yet displayed. This will only show for 1
   // frame though, because we will reissue a new frame right away without that
   // composited data.
-  RunCompositingCallbacks();
+  ui::Compositor* compositor = GetCompositor();
+  RunCompositingCallbacks(compositor);
   locks_pending_draw_.clear();
-  ui::Compositor* compositor = GetCompositor();
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
   DetachFromInputMethod();
 }
 
 ui::Compositor* RenderWidgetHostViewAura::GetCompositor() {
   aura::RootWindow* root_window = window_->GetRootWindow();
   return root_window ? root_window->compositor() : NULL;
 }
 
@@ skipping 10 matching lines @@
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void content::RenderWidgetHostViewPort::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }