Aura: Resize locks with --ui-enable-threaded-compositing

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 149 matching lines @@
 
   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),
-        compositor_lock_(root_window_->GetCompositorLock()) {
+        compositor_lock_(root_window_->compositor()->GetCompositorLock()) {
     root_window_->HoldMouseMoves();
 
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RenderWidgetHostViewAura::ResizeLock::CancelLock,
                    AsWeakPtr()),
         base::TimeDelta::FromMilliseconds(kResizeLockTimeoutMs));
   }
 
   ~ResizeLock() {
     CancelLock();
   }
 
+  bool IsLocked() {
+    return root_window_ != NULL;
+  }
+
   void UnlockCompositor() {
     compositor_lock_ = NULL;
   }
 
   void CancelLock() {
     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_;
+  scoped_refptr<ui::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 60 matching lines @@
   return host_;
 }
 
 void RenderWidgetHostViewAura::WasShown() {
   if (!host_->is_hidden())
     return;
   host_->WasShown();
 
   if (!current_surface_ && host_->is_accelerated_compositing_active() &&
       !released_front_lock_.get()) {
-    released_front_lock_ = window_->GetRootWindow()->GetCompositorLock();
+    released_front_lock_ = GetCompositor()->GetCompositorLock();
   }
 
   AdjustSurfaceProtection();
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   if (host_->is_hidden())
     return;
   host_->WasHidden();
 
@@ skipping 256 matching lines @@
   }
 
   if (current_surface_ != 0 && host_->is_accelerated_compositing_active()) {
     ui::Texture* container = image_transport_clients_[current_surface_];
     window_->SetExternalTexture(container);
     current_surface_in_use_by_compositor_ = true;
 
     if (!container) {
       resize_locks_.clear();
     } else {
-      typedef std::vector<linked_ptr<ResizeLock> > ResizeLockList;
-      ResizeLockList::iterator it = resize_locks_.begin();
-      while (it != resize_locks_.end()) {
-        gfx::Size container_size = ConvertSizeToDIP(this,
-            container->size());
-        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);
-      }
+      UpdateResizeLocks(ConvertSizeToDIP(this, container->size()));
     }
   } else {
     window_->SetExternalTexture(NULL);
     if (ShouldReleaseFrontSurface() &&
         host_->is_accelerated_compositing_active()) {
       // The current surface may have pipelined gl commands, so always wait for
       // the next composite to start.  If the current surface is still null,
       // then we really know its no longer in use.
       ui::Compositor* compositor = GetCompositor();
       if (compositor) {
-        on_compositing_will_start_callbacks_.push_back(
+        AddCompositingStartedCallback(
             base::Bind(&RenderWidgetHostViewAura::
                            SetSurfaceNotInUseByCompositor,
                        AsWeakPtr()));
         if (!compositor->HasObserver(this))
           compositor->AddObserver(this);
       }
     }
     resize_locks_.clear();
   }
 }
 
+void RenderWidgetHostViewAura::UpdateResizeLocks(
+    const gfx::Size& surface_size_in_dip) {
+  typedef std::vector<linked_ptr<ResizeLock> > ResizeLockList;
+
+  // Remove locks that timed out.
+  ResizeLockList::iterator it = resize_locks_.begin();
+  while (it != resize_locks_.end()) {
+    if ((*it)->IsLocked())
+      break;
+    ++it;
+  }
+  resize_locks_.erase(resize_locks_.begin(), it);
+
+  // Remove locks if we've got got the right size.

[piman, 2012/07/31 23:42:17]

typo: got got

[jonathan.backer, 2012/08/01 17:22:43]

Done.

+  it = resize_locks_.begin();
+  while (it != resize_locks_.end()) {
+    if ((*it)->expected_size() == surface_size_in_dip)
+      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);
+  }
+}
+
+bool RenderWidgetHostViewAura::CanFastTrackACK(
+    const gfx::Size& surface_size_in_dip) {
+  std::vector<linked_ptr<ResizeLock> >::iterator it = resize_locks_.begin();
+  if (it == resize_locks_.end())
+    return false;
+
+  if (!(*it)->IsLocked())
+    return false;
+
+  UpdateResizeLocks(surface_size_in_dip);
+  return !resize_locks_.empty();
+}
+
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
   surface_route_id_ = params_in_pixel.route_id;
   // If protection state changed, then this swap is stale. We must still ACK but
   // do not update current_surface_ since it may have been discarded.
   if (host_->is_hidden() ||
       (params_in_pixel.protection_state_id &&
           params_in_pixel.protection_state_id != protection_state_id_)) {
     DCHECK(!current_surface_);
     if (!params_in_pixel.skip_ack)
       InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, NULL);
     return;
   }
-  current_surface_ = params_in_pixel.surface_handle;
   // If we don't require an ACK that means the content is not a fresh updated
   // new frame, rather we are just resetting our handle to some old content that
   // we still hadn't discarded. Although we could display immediately, by not
   // resetting the compositor lock here, we give us some time to get a fresh
   // frame which means fewer content flashes.
   if (!params_in_pixel.skip_ack)
     released_front_lock_ = NULL;
 
-  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.
     if (!params_in_pixel.skip_ack)
       InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, NULL);
   } else {
     DCHECK(image_transport_clients_.find(params_in_pixel.surface_handle) !=
            image_transport_clients_.end());
     gfx::Size surface_size_in_pixel =
         image_transport_clients_[params_in_pixel.surface_handle]->size();
-    gfx::Size surface_size = ConvertSizeToDIP(this,
-                                                       surface_size_in_pixel);
+    gfx::Size surface_size = ConvertSizeToDIP(this, surface_size_in_pixel);
     window_->SchedulePaintInRect(gfx::Rect(surface_size));
 
-    if (!params_in_pixel.skip_ack) {
-      if (!resize_locks_.empty()) {
-        // If we are waiting for the resize, fast-track the ACK.
-        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);
-        }
+    if (params_in_pixel.skip_ack) {
+      current_surface_ = params_in_pixel.surface_handle;
+      UpdateExternalTexture();
+    } else {
+      if (CanFastTrackACK(surface_size)) {
+        // Skip the flip.
+        InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, NULL);
       } else {
-        // Add sending an ACK to the list of things to do OnCompositingWillStart
-        on_compositing_will_start_callbacks_.push_back(
+        current_surface_ = params_in_pixel.surface_handle;
+        UpdateExternalTexture();
+
+        AddCompositingStartedCallback(
             base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
                        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) {
   surface_route_id_ = params_in_pixel.route_id;
   // If visible state changed, then this PSB is stale. We must still ACK but
   // do not update current_surface_.
   if (host_->is_hidden() ||
       (params_in_pixel.protection_state_id &&
           params_in_pixel.protection_state_id != protection_state_id_)) {
     DCHECK(!current_surface_);
     InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, NULL);
     return;
   }
-  current_surface_ = params_in_pixel.surface_handle;
-  released_front_lock_ = NULL;
-  DCHECK(current_surface_);
-  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, NULL);
   } else {
     DCHECK(image_transport_clients_.find(params_in_pixel.surface_handle) !=
            image_transport_clients_.end());
     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 = 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));
 
     // Damage may not have been DIP aligned, so inflate damage to compensate
     // for any round-off error.
     rect_to_paint.Inset(-1, -1);
     rect_to_paint.Intersect(window_->bounds());
 
     window_->SchedulePaintInRect(rect_to_paint);
 
-    if (!resize_locks_.empty()) {
-      // If we are waiting for the resize, fast-track the ACK.
-      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);
-      }
+    if (CanFastTrackACK(ConvertSizeToDIP(this, surface_size_in_pixel))) {
+      // Skip the flip.
+      InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, NULL);
     } else {
-      // Add sending an ACK to the list of things to do OnCompositingWillStart
-      on_compositing_will_start_callbacks_.push_back(
+      current_surface_ = params_in_pixel.surface_handle;
+      released_front_lock_ = NULL;
+      DCHECK(current_surface_);
+      UpdateExternalTexture();
+
+      AddCompositingStartedCallback(

[piman, 2012/07/31 23:42:17]

So, in the single-thread case, we're moving the sync point from before the draw
to after the swap , which is a little sad. Is it not possible to keep that
feature?

[jonathan.backer, 2012/08/01 17:22:43]

Done.

           base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
                      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
@@ skipping 652 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) {
-  RunCompositingWillStartCallbacks(compositor);
-}
-
 void RenderWidgetHostViewAura::OnCompositingStarted(
     ui::Compositor* compositor) {
+  RunCompositingStartedCallbacks(compositor);
   locks_pending_draw_.clear();
 }
 
 void RenderWidgetHostViewAura::OnCompositingEnded(
     ui::Compositor* compositor) {
 }
 
 void RenderWidgetHostViewAura::OnCompositingAborted(
     ui::Compositor* compositor) {
 }
@@ skipping 130 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::RunCompositingDidCommitCallbacks(
+void RenderWidgetHostViewAura::RunCompositingStartedCallbacks(
     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);
+  std::vector<CommitIdAndCallback> uncalled;
+  for (std::vector<CommitIdAndCallback>::const_iterator
+      it = on_compositing_started_callbacks_.begin();
+      it != on_compositing_started_callbacks_.end(); ++it) {
+    if (it->first <= compositor->last_commit_id()) {
+      it->second.Run(compositor);
+    } else {
+      uncalled.push_back(*it);
+    }
   }
-  on_compositing_did_commit_callbacks_.clear();
+  on_compositing_started_callbacks_.swap(uncalled);
 }
 
-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(compositor);
-  }
-  on_compositing_will_start_callbacks_.clear();
+void RenderWidgetHostViewAura::AddCompositingStartedCallback(
+    base::Callback<void(ui::Compositor*)> callback) {
+  ui::Compositor* compositor = GetCompositor();
+  DCHECK(compositor);
+  on_compositing_started_callbacks_.push_back(
+      CommitIdAndCallback(compositor->last_commit_id() + 1, callback));
+  if (!compositor->HasObserver(this))
+    compositor->AddObserver(this);
 }
 
 // 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, 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.
   ui::Compositor* compositor = GetCompositor();
-  RunCompositingDidCommitCallbacks(compositor);
-  RunCompositingWillStartCallbacks(compositor);
+  RunCompositingStartedCallbacks(compositor);
   locks_pending_draw_.clear();
   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 12 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content