Aura: ACK on the start of the frame generation for greater async.

By responding to AcceleratedSurfaceBuffersSwapped and AcceleratedSurfacePostSubBuffer early, we allow the GPU process to service the renderer while the browser UI is generating it's next frame. This buys us about 2 ms of processing according to chrome://tracing

BUG=none
TEST=none


Review URL: https://chromiumcodereview.appspot.com/10692044

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@144990 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 57 insertions, 24 deletions

diff --git a/ash/wm/window_animations.cc b/ash/wm/window_animations.cc
index 5628f0a..28a2480 100644
--- a/ash/wm/window_animations.cc
+++ b/ash/wm/window_animations.cc
@@ -6,6 +6,9 @@
 
 #include <math.h>
 
+#include <algorithm>
+#include <vector>
+
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/shell.h"
@@ -192,8 +195,8 @@ class HidingWindowAnimationObserver : public ui::ImplicitAnimationObserver,
 // visibility to 'false' when done. This doesn't need the complexity of
 // HidingWindowAnimationObserver as the window isn't closing, and if it does a
 // HidingWindowAnimationObserver will be created.
-class WorkspaceHidingWindowAnimationObserver :
-      public ui::ImplicitAnimationObserver {
+class WorkspaceHidingWindowAnimationObserver
+    : public ui::ImplicitAnimationObserver {
  public:
   explicit WorkspaceHidingWindowAnimationObserver(aura::Window* window)
       : layer_(window->layer()) {
@@ -563,6 +566,8 @@ class CrossFadeObserver : public ui::CompositorObserver,
   }
 
   // ui::CompositorObserver overrides:
+  virtual void OnCompositingWillStart(ui::Compositor* compositor) OVERRIDE {
+  }
   virtual void OnCompositingStarted(ui::Compositor* compositor) OVERRIDE {
   }
   virtual void OnCompositingEnded(ui::Compositor* compositor) OVERRIDE {
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
index b115829..e0e3c52 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
@@ -564,8 +564,8 @@ void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
       // If we are waiting for the resize, fast-track the ACK.
       InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id);
     } else {
-      // Add sending an ACK to the list of things to do OnCompositingStarted
-      on_compositing_started_callbacks_.push_back(
+      // 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,
@@ -605,8 +605,8 @@ void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
       // If we are waiting for the resize, fast-track the ACK.
       InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id);
     } else {
-      // Add sending an ACK to the list of things to do OnCompositingStarted
-      on_compositing_started_callbacks_.push_back(
+      // 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,
@@ -1213,10 +1213,15 @@ void RenderWidgetHostViewAura::OnLostActive() {
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::CompositorObserver implementation:
 
+
+void RenderWidgetHostViewAura::OnCompositingWillStart(
+    ui::Compositor* compositor) {
+  RunCompositingCallbacks();
+}
+
 void RenderWidgetHostViewAura::OnCompositingStarted(
     ui::Compositor* compositor) {
   locks_pending_draw_.clear();
-  RunCompositingCallbacks();
   compositor->RemoveObserver(this);
 }
 
@@ -1361,11 +1366,11 @@ bool RenderWidgetHostViewAura::ShouldMoveToCenter() {
 
 void RenderWidgetHostViewAura::RunCompositingCallbacks() {
   for (std::vector< base::Callback<void(void)> >::const_iterator
-      it = on_compositing_started_callbacks_.begin();
-      it != on_compositing_started_callbacks_.end(); ++it) {
+      it = on_compositing_will_start_callbacks_.begin();
+      it != on_compositing_will_start_callbacks_.end(); ++it) {
     it->Run();
   }
-  on_compositing_started_callbacks_.clear();
+  on_compositing_will_start_callbacks_.clear();
 }
 
 void RenderWidgetHostViewAura::InsertSyncPointAndACK(int32 route_id,
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.h b/content/browser/renderer_host/render_widget_host_view_aura.h
index e94cc0b..1af2487 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.h
+++ b/content/browser/renderer_host/render_widget_host_view_aura.h
@@ -195,6 +195,7 @@ class RenderWidgetHostViewAura
   friend class WindowObserver;
 
   // Overridden from ui::CompositorObserver:
+  virtual void OnCompositingWillStart(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingStarted(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingEnded(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingAborted(ui::Compositor* compositor) OVERRIDE;
@@ -294,7 +295,8 @@ class RenderWidgetHostViewAura
   // Current tooltip text.
   string16 tooltip_;
 
-  std::vector< base::Callback<void(void)> > on_compositing_started_callbacks_;
+  std::vector< base::Callback<void(void)> >
+      on_compositing_will_start_callbacks_;
 
   std::map<uint64, scoped_refptr<ImageTransportClient> >
       image_transport_clients_;
diff --git a/ui/aura/bench/bench_main.cc b/ui/aura/bench/bench_main.cc
index be3465b..7d416757 100644
--- a/ui/aura/bench/bench_main.cc
+++ b/ui/aura/bench/bench_main.cc
@@ -91,6 +91,8 @@ class BenchCompositorObserver : public ui::CompositorObserver {
         frames_(0),
         max_frames_(max_frames) {
   }
+  virtual void OnCompositingWillStart(Compositor* compositor) OVERRIDE {}
+
   virtual void OnCompositingStarted(Compositor* compositor) OVERRIDE {}
 
   virtual void OnCompositingEnded(Compositor* compositor) OVERRIDE {
diff --git a/ui/aura/root_window.cc b/ui/aura/root_window.cc
index 7667c51..3165eed 100644
--- a/ui/aura/root_window.cc
+++ b/ui/aura/root_window.cc
@@ -560,6 +560,9 @@ void RootWindow::ScheduleDraw() {
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::CompositorObserver implementation:
 
+void RootWindow::OnCompositingWillStart(ui::Compositor*) {
+}
+
 void RootWindow::OnCompositingStarted(ui::Compositor*) {
 }
 
diff --git a/ui/aura/root_window.h b/ui/aura/root_window.h
index a0d5811..2ed5931 100644
--- a/ui/aura/root_window.h
+++ b/ui/aura/root_window.h
@@ -57,14 +57,14 @@ class TouchEvent;
 // responsiveness of the UI, so the compositor tree should be kept in a
 // "reasonable" state while the lock is held.
 // Don't instantiate this class directly, use RootWindow::GetCompositorLock.
-class AURA_EXPORT CompositorLock :
-    public base::RefCounted<CompositorLock>,
-    public base::SupportsWeakPtr<CompositorLock> {
+class AURA_EXPORT CompositorLock
+    : public base::RefCounted<CompositorLock>,
+      public base::SupportsWeakPtr<CompositorLock> {
  private:
   friend class base::RefCounted<CompositorLock>;
   friend class RootWindow;
 
-  CompositorLock(RootWindow* root_window);
+  explicit CompositorLock(RootWindow* root_window);
   ~CompositorLock();
 
   void CancelLock();
@@ -248,6 +248,7 @@ class AURA_EXPORT RootWindow : public ui::CompositorDelegate,
   virtual void ScheduleDraw() OVERRIDE;
 
   // Overridden from ui::CompositorObserver:
+  virtual void OnCompositingWillStart(ui::Compositor*) OVERRIDE;
   virtual void OnCompositingStarted(ui::Compositor*) OVERRIDE;
   virtual void OnCompositingEnded(ui::Compositor*) OVERRIDE;
   virtual void OnCompositingAborted(ui::Compositor*) OVERRIDE;
diff --git a/ui/compositor/compositor.cc b/ui/compositor/compositor.cc
index c18488b..6b678bc 100644
--- a/ui/compositor/compositor.cc
+++ b/ui/compositor/compositor.cc
@@ -4,6 +4,8 @@
 
 #include "ui/compositor/compositor.h"
 
+#include <algorithm>
+
 #include "base/command_line.h"
 #include "base/threading/thread_restrictions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositor.h"
@@ -222,6 +224,9 @@ void Compositor::Draw(bool force_clear) {
     return;
 
   last_started_frame_++;
+  FOR_EACH_OBSERVER(CompositorObserver,
+                    observer_list_,
+                    OnCompositingWillStart(this));
 
   // TODO(nduca): Temporary while compositor calls
   // compositeImmediately() directly.
@@ -259,7 +264,7 @@ bool Compositor::ReadPixels(SkBitmap* bitmap,
 }
 
 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
-  DCHECK(scale > 0);
+  DCHECK_GT(scale, 0);
   if (size_in_pixel.IsEmpty() || scale <= 0)
     return;
   size_ = size_in_pixel;
@@ -325,8 +330,8 @@ WebKit::WebGraphicsContext3D* Compositor::createContext3D() {
   if (test_compositor_enabled) {
     ui::TestWebGraphicsContext3D* test_context =
       new ui::TestWebGraphicsContext3D();
-   test_context->Initialize();
-   return test_context;
+    test_context->Initialize();
+    return test_context;
   } else {
     return ContextFactory::GetInstance()->CreateContext(this);
   }
@@ -354,13 +359,13 @@ void Compositor::SwizzleRGBAToBGRAAndFlip(unsigned char* pixels,
                                           const gfx::Size& image_size) {
   // Swizzle from RGBA to BGRA
   size_t bitmap_size = 4 * image_size.width() * image_size.height();
-  for(size_t i = 0; i < bitmap_size; i += 4)
+  for (size_t i = 0; i < bitmap_size; i += 4)
     std::swap(pixels[i], pixels[i + 2]);
 
   // Vertical flip to transform from GL co-ords
   size_t row_size = 4 * image_size.width();
   scoped_array<unsigned char> tmp_row(new unsigned char[row_size]);
-  for(int row = 0; row < image_size.height() / 2; row++) {
+  for (int row = 0; row < image_size.height() / 2; row++) {
     memcpy(tmp_row.get(),
            &pixels[row * row_size],
            row_size);
diff --git a/ui/compositor/compositor_observer.h b/ui/compositor/compositor_observer.h
index dc5393e..557141a 100644
--- a/ui/compositor/compositor_observer.h
+++ b/ui/compositor/compositor_observer.h
@@ -15,6 +15,9 @@ class Compositor;
 // A compositor observer is notified when compositing completes.
 class COMPOSITOR_EXPORT CompositorObserver {
  public:
+  // Called when compositing will start.
+  virtual void OnCompositingWillStart(Compositor* compositor) = 0;
+
   // Called when compositing started: it has taken all the layer changes into
   // account and has issued the graphics commands.
   virtual void OnCompositingStarted(Compositor* compositor) = 0;
@@ -29,6 +32,6 @@ class COMPOSITOR_EXPORT CompositorObserver {
   virtual ~CompositorObserver() {}
 };
 
-} // namespace ui
+}  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_OBSERVER_H_
diff --git a/ui/compositor/layer_unittest.cc b/ui/compositor/layer_unittest.cc
index 745534b..a1e805d 100644
--- a/ui/compositor/layer_unittest.cc
+++ b/ui/compositor/layer_unittest.cc
@@ -323,18 +323,24 @@ class NullLayerDelegate : public LayerDelegate {
 // Remembers if it has been notified.
 class TestCompositorObserver : public CompositorObserver {
  public:
-  TestCompositorObserver() : started_(false), ended_(false), aborted_(false) {}
+  TestCompositorObserver()
+      : will_start_(false), started_(false), ended_(false), aborted_(false) {}
 
-  bool notified() const { return started_ && ended_; }
+  bool notified() const { return will_start_ && started_ && ended_; }
   bool aborted() const { return aborted_; }
 
   void Reset() {
+    will_start_ = false;
     started_ = false;
     ended_ = false;
     aborted_ = false;
   }
 
  private:
+  virtual void OnCompositingWillStart(Compositor* compositor) OVERRIDE {
+    will_start_ = true;
+  }
+
   virtual void OnCompositingStarted(Compositor* compositor) OVERRIDE {
     started_ = true;
   }
@@ -347,6 +353,7 @@ class TestCompositorObserver : public CompositorObserver {
     aborted_ = true;
   }
 
+  bool will_start_;
   bool started_;
   bool ended_;
   bool aborted_;
@@ -1295,4 +1302,4 @@ TEST_F(LayerWithDelegateTest, SetBoundsWhenInvisible) {
   EXPECT_TRUE(delegate.painted());
 }
 
-} // namespace ui
+}  // namespace ui