aura: fast resizes for accelerated pages

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/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/renderer_host/backing_store_skia.h"
@@ skipping 109 matching lines @@
   RenderWidgetHostViewAura* view_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserver);
 };
 
 class RenderWidgetHostViewAura::ResizeLock :
     public base::SupportsWeakPtr<RenderWidgetHostViewAura::ResizeLock> {
  public:
   ResizeLock(aura::RootWindow* root_window, const gfx::Size new_size)
       : root_window_(root_window),
-        new_size_(new_size) {
+        new_size_(new_size),
+        compositor_lock_(root_window_->GetCompositorLock()) {
     root_window_->HoldMouseMoves();
 
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RenderWidgetHostViewAura::ResizeLock::CancelLock,
                    AsWeakPtr()),
         kResizeLockTimeoutMs);
   }
 
   ~ResizeLock() {
     CancelLock();
   }
 
+  void UnlockCompositor() {
+    compositor_lock_ = NULL;
+  }
+
   void CancelLock() {
-    if (root_window_)
-      root_window_->ReleaseMouseMoves();
+    if (!root_window_)
+      return;
+    UnlockCompositor();
+    root_window_->ReleaseMouseMoves();
     root_window_ = NULL;
   }
 
   const gfx::Size& expected_size() const {
     return new_size_;
   }
 
  private:
   aura::RootWindow* root_window_;
   gfx::Size new_size_;
+  scoped_refptr<aura::CompositorLock> compositor_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ResizeLock);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host)
     : host_(RenderWidgetHostImpl::From(host)),
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
@@ skipping 245 matching lines @@
 
     ImageTransportClient* container =
         image_transport_clients_[current_surface_];
     if (container)
       container->Update();
     window_->SetExternalTexture(container);
 
     if (!container) {
       resize_locks_.clear();
     } else {
-      std::vector<linked_ptr<ResizeLock> >::iterator it = resize_locks_.begin();
+      typedef std::vector<linked_ptr<ResizeLock> > ResizeLockList;
+      ResizeLockList::iterator it = resize_locks_.begin();
       while (it != resize_locks_.end()) {
         if ((*it)->expected_size() == container->size())
           break;
         ++it;
       }
       if (it != resize_locks_.end()) {
         ++it;
         ui::Compositor* compositor = GetCompositor();
         if (compositor) {
           // Delay the release of the lock until we've kicked a frame with the
           // new texture, to avoid resizing the UI before we have a chance to
           // draw a "good" frame.
           locks_pending_draw_.insert(
               locks_pending_draw_.begin(), resize_locks_.begin(), it);
+          // However since we got the size we were looking for, unlock the
+          // compositor.
+          for (ResizeLockList::iterator it2 = resize_locks_.begin();
+              it2 !=it; ++it2) {
+            it2->get()->UnlockCompositor();
+          }
           if (!compositor->HasObserver(this))
             compositor->AddObserver(this);
         }
         resize_locks_.erase(resize_locks_.begin(), it);
       }
     }
   } else {
     window_->SetExternalTexture(NULL);
     resize_locks_.clear();
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   current_surface_ = params.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.
     RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
   } else {
     gfx::Size surface_size =
         image_transport_clients_[params.surface_handle]->size();
     window_->SchedulePaintInRect(gfx::Rect(surface_size));
 
-    // Add sending an ACK to the list of things to do OnCompositingEnded
-    on_compositing_ended_callbacks_.push_back(
-        base::Bind(&RenderWidgetHostImpl::AcknowledgeSwapBuffers,
-                   params.route_id, gpu_host_id));
-    if (!compositor->HasObserver(this))
-      compositor->AddObserver(this);
+    if (!resize_locks_.empty() && !compositor->DrawPending()) {

[jonathan.backer, 2012/03/23 15:48:00]

I'm not sure that !compositor->DrawPending() is strong enough synchronization.
But that was never the intent of the delayed ACK: it's throttling so that the
renderer does not generate more frames than the UI can display --- so it makes
perfect sense to fast track here.

[piman, 2012/03/23 17:41:09]

So, we don't pipeline draws on the client side (browser process) for the
compositor. That is, between OnCompositorEnded() and the next Draw() (i.e.
!DrawPending()), the GPU process doesn't have any commands in flight for the UI,
and it's absolutely safe to allow the swap to carry on - we switched the texture
in the UI, so if we were to draw another frame while the renderer is working on
its next one, we won't display a partial frame.
If DrawPending() is true (e.g. we grabbed the lock between Draw() and
OnCompositorEnded(), or the lock has expired), then it's not safe and we have to
wait until the OnCompositingEnded() - which we'll do below.
We're losing throttling while we're resizing, but that's intentional because
we've blocked the UI to let the renderer give us a frame ASAP. It's true that in
theory a renderer could send other frames before the resize, but we have to let
them through to allow the resize to come.

+      // If we are waiting for the resize, fast-track the ACK.
+      // However only do so if we're not between the Draw() and the
+      // OnCompositingEnded(), because out-of-order execution in the GPU process
+      // might corrupt the "front buffer" for the currently issued frame.
+      RenderWidgetHostImpl::AcknowledgePostSubBuffer(
+          params.route_id, gpu_host_id);
+    } else {
+      // Add sending an ACK to the list of things to do OnCompositingEnded
+      on_compositing_ended_callbacks_.push_back(
+          base::Bind(&RenderWidgetHostImpl::AcknowledgeSwapBuffers,
+                     params.route_id, gpu_host_id));
+      if (!compositor->HasObserver(this))
+        compositor->AddObserver(this);
+    }
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   current_surface_ = params.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
     RenderWidgetHostImpl::AcknowledgePostSubBuffer(
         params.route_id, gpu_host_id);
   } else {
     gfx::Size surface_size =
         image_transport_clients_[params.surface_handle]->size();
 
     // Co-ordinates come in OpenGL co-ordinate space.
     // We need to convert to layer space.
     window_->SchedulePaintInRect(gfx::Rect(
         params.x,
         surface_size.height() - params.y - params.height,
         params.width,
         params.height));
 
-    // Add sending an ACK to the list of things to do OnCompositingEnded
-    on_compositing_ended_callbacks_.push_back(
-        base::Bind(&RenderWidgetHostImpl::AcknowledgePostSubBuffer,
-                   params.route_id, gpu_host_id));
-    if (!compositor->HasObserver(this))
-      compositor->AddObserver(this);
+    if (!resize_locks_.empty() && !compositor->DrawPending()) {
+      // If we are waiting for the resize, fast-track the ACK.
+      // However only do so if we're not between the Draw() and the
+      // OnCompositingEnded(), because out-of-order execution in the GPU process
+      // might corrupt the "front buffer" for the currently issued frame.
+      RenderWidgetHostImpl::AcknowledgePostSubBuffer(
+          params.route_id, gpu_host_id);
+    } else {
+      // Add sending an ACK to the list of things to do OnCompositingEnded
+      on_compositing_ended_callbacks_.push_back(
+          base::Bind(&RenderWidgetHostImpl::AcknowledgePostSubBuffer,
+                     params.route_id, gpu_host_id));
+      if (!compositor->HasObserver(this))
+        compositor->AddObserver(this);
+    }
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceNew(
       int32 width,
       int32 height,
       uint64* surface_handle,
@@ skipping 700 matching lines @@
     WebKit::WebScreenInfo* results) {
   const gfx::Size size = gfx::Screen::GetPrimaryMonitorSize();
   results->rect = WebKit::WebRect(0, 0, size.width(), size.height());
   results->availableRect = results->rect;
   // TODO(derat): Don't hardcode this?
   results->depth = 24;
   results->depthPerComponent = 8;
   results->verticalDPI = 96;
   results->horizontalDPI = 96;
 }