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"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "content/browser/renderer_host/backing_store_aura.h"
 #include "content/browser/renderer_host/dip_util.h"
-#include "content/browser/renderer_host/image_transport_client.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
@@ skipping 415 matching lines @@
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurface(
     const gfx::Size& size,
     skia::PlatformCanvas* output,
     base::Callback<void(bool)> callback) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
   ui::Compositor* compositor = GetCompositor();
   if (!compositor)
     return;
 
-  std::map<uint64, scoped_refptr<ImageTransportClient> >::iterator it =
+  std::map<uint64, scoped_refptr<ui::Texture> >::iterator it =
       image_transport_clients_.find(current_surface_);
   if (it == image_transport_clients_.end())
     return;
 
-  ImageTransportClient* container = it->second;
+  ui::Texture* container = it->second;
   DCHECK(container);
 
   gfx::Size size_in_pixel = content::ConvertSizeToPixel(this, size);
   if (!output->initialize(
       size_in_pixel.width(), size_in_pixel.height(), true))
     return;
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   content::GLHelper* gl_helper = factory->GetGLHelper(compositor);
   if (!gl_helper)
@@ skipping 29 matching lines @@
     // Don't scale the contents in accelerated mode because the renderer takes
     // care of it.
     window_->layer()->set_scale_content(
         !host_->is_accelerated_compositing_active());
 
     accelerated_compositing_state_changed_ = false;
   }
 
   if (current_surface_ != 0 &&
       host_->is_accelerated_compositing_active()) {
-    ImageTransportClient* container =
+    ui::Texture* container =
         image_transport_clients_[current_surface_];
-    if (container)
-      container->Update();
     window_->SetExternalTexture(container);
 
     released_front_lock_ = NULL;
 
     if (!container) {
       resize_locks_.clear();
     } else {
       typedef std::vector<linked_ptr<ResizeLock> > ResizeLockList;
       ResizeLockList::iterator it = resize_locks_.begin();
       while (it != resize_locks_.end()) {
@@ skipping 33 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, NULL);
   } 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);
+      if (compositor->IsThreaded()) {
+        // We need the compositor thread to pick up the active buffer before
+        // ACKing.
+        on_compositing_did_commit_callbacks_.push_back(
+            base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
+                       params_in_pixel.route_id,
+                       gpu_host_id));
+        if (!compositor->HasObserver(this))
+          compositor->AddObserver(this);
+      } else {
+        // The compositor will pickup the active buffer during a draw, so we
+        // can ACK immediately.
+        InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id,
+                              compositor);
+      }
     } 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, NULL);
   } 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);
+      if (compositor->IsThreaded()) {
+        // We need the compositor thread to pick up the active buffer before
+        // ACKing.
+        on_compositing_did_commit_callbacks_.push_back(
+            base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
+                       params_in_pixel.route_id,
+                       gpu_host_id));
+        if (!compositor->HasObserver(this))
+          compositor->AddObserver(this);
+      } else {
+        // The compositor will pickup the active buffer during a draw, so we
+        // can ACK immediately.
+        InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id,
+                              compositor);
+      }
     } 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() {
 }
 
 bool RenderWidgetHostViewAura::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
   // Aura doesn't use GetBackingStore for accelerated pages, so it doesn't
   // matter what is returned here as GetBackingStore is the only caller of this
   // method. TODO(jbates) implement this if other Aura code needs it.
   return false;
 }
 
+// TODO(backer): Drop the |shm_handle| once I remove some unused service side
+// code.
 void RenderWidgetHostViewAura::AcceleratedSurfaceNew(
       int32 width_in_pixel,
       int32 height_in_pixel,
       uint64* surface_handle,
       TransportDIB::Handle* shm_handle) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-  scoped_refptr<ImageTransportClient> surface(factory->CreateTransportClient(
-        gfx::Size(width_in_pixel, height_in_pixel), surface_handle));
+  scoped_refptr<ui::Texture> surface(factory->CreateTransportClient(
+      gfx::Size(width_in_pixel, height_in_pixel), surface_handle,
+      GetCompositor()));
   if (!surface) {
-    LOG(ERROR) << "Failed to create ImageTransportClient";
+    LOG(ERROR) << "Failed to create ImageTransport texture";
     return;
   }
-  *shm_handle = surface->Handle();
 
   image_transport_clients_[*surface_handle] = surface;
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease(
     uint64 surface_handle) {
   if (current_surface_ == surface_handle) {
     current_surface_ = 0;
     UpdateExternalTexture();
   }
@@ skipping 553 matching lines @@
 
 void RenderWidgetHostViewAura::OnActivated() {
 }
 
 void RenderWidgetHostViewAura::OnLostActive() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::CompositorObserver implementation:
 
+void RenderWidgetHostViewAura::OnCompositingDidCommit(
+    ui::Compositor* compositor) {
+  RunCompositingDidCommitCallbacks(compositor);
+}
 
 void RenderWidgetHostViewAura::OnCompositingWillStart(
     ui::Compositor* compositor) {
-  RunCompositingCallbacks();
+  RunCompositingWillStartCallbacks(compositor);
 }
 
 void RenderWidgetHostViewAura::OnCompositingStarted(
     ui::Compositor* compositor) {
   locks_pending_draw_.clear();
-  compositor->RemoveObserver(this);
 }
 
-void RenderWidgetHostViewAura::OnCompositingEnded(ui::Compositor* compositor) {
+void RenderWidgetHostViewAura::OnCompositingEnded(
+    ui::Compositor* compositor) {
 }
 
 void RenderWidgetHostViewAura::OnCompositingAborted(
     ui::Compositor* compositor) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ImageTransportFactoryObserver implementation:
 
 void RenderWidgetHostViewAura::OnLostResources(ui::Compositor* compositor) {
@@ skipping 118 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::RunCompositingDidCommitCallbacks(
+    ui::Compositor* compositor) {
+  for (std::vector< base::Callback<void(ui::Compositor*)> >::const_iterator
+      it = on_compositing_did_commit_callbacks_.begin();
+      it != on_compositing_did_commit_callbacks_.end(); ++it) {
+    it->Run(compositor);
+  }
+  on_compositing_did_commit_callbacks_.clear();
+}
+
+void RenderWidgetHostViewAura::RunCompositingWillStartCallbacks(
+    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) {
-  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+// static
+void RenderWidgetHostViewAura::InsertSyncPointAndACK(
+     int32 route_id, int gpu_host_id, ui::Compositor* compositor) {
+  uint32 sync_point = 0;
+  // If we have no compositor, so we must still send the ACK. A zero
+  // sync point will not be waited for in the GPU process.
+  if (compositor) {
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    sync_point = factory->InsertSyncPoint(compositor);
+  }
+
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
-      route_id, gpu_host_id, factory->InsertSyncPoint(GetCompositor()));
+      route_id, gpu_host_id, sync_point);
 }
 
 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();
+  RunCompositingDidCommitCallbacks(compositor);
+  RunCompositingWillStartCallbacks(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);
 }