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()) {
+      // 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;
 }