compositor: Tick the UI animations from cc, instead of from timer callbacks.

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "cc/base/latency_info_swap_promise.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/context_provider.h"
 #include "cc/trees/layer_tree_host.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/compositor_vsync_manager.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/layer_animator_collection.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
 const double kDefaultRefreshRate = 60.0;
 const double kTestRefreshRate = 200.0;
 
 ui::ContextFactory* g_context_factory = NULL;
@@ skipping 211 matching lines @@
     return;
 
   DCHECK_NE(swap_state_, SWAP_POSTED);
   swap_state_ = SWAP_NONE;
 
   last_started_frame_++;
   if (!IsLocked()) {
     // TODO(nduca): Temporary while compositor calls
     // compositeImmediately() directly.
     Layout();
-    host_->Composite(gfx::FrameTime::Now());
+    base::TimeTicks now = gfx::FrameTime::Now();
+    Animate(now);

[piman, 2014/05/23 18:20:06]

I'm not sure I understand what in the animation code triggers a compositor frame
to make sure we call Animate() the first time.

[sadrul, 2014/05/23 18:32:28]

I am not sure if there is anything to ensure this first call. Ali might know
more.

Do you suggest an explicit call to the compositor from the collection?

[ajuma, 2014/05/23 19:15:14]

There doesn't seem to be anything to ensure this. (In the existing code, adding
a LayerAnimatior to an empty AnimationContainer causes the AnimationContainer to
start its timer.) An explicit call to the compositor when adding an animator to
an empty collection seems reasonable (perhaps via a minimal
LayerAnimatorCollection<something> interface rather than exposing all of
Compositor to the collection).

+    host_->Composite(now);
   }
   if (swap_state_ == SWAP_NONE)
     NotifyEnd();
 }
 
 void Compositor::ScheduleFullRedraw() {
   host_->SetNeedsRedraw();
 }
 
 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
@@ skipping 39 matching lines @@
 }
 
 void Compositor::RemoveObserver(CompositorObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 bool Compositor::HasObserver(CompositorObserver* observer) {
   return observer_list_.HasObserver(observer);
 }
 
+void Compositor::Animate(base::TimeTicks frame_begin_time) {
+  LayerAnimatorCollection::GetInstance()->Progress(frame_begin_time);

[piman, 2014/05/23 18:20:06]

We have one compositor per root window, which are on their own schedule.
Doesn't this mean that we'll evaluate all animations from all layer for each
compositor? I.e. N times if you have N root windows?

Couldn't the LayerAnimatorCollection be one per compositor, so that you only
animate each layer once per frame?

[sadrul, 2014/05/23 18:32:28]

Ah, good point. Right now, the LayerAnimator does not know about the compositor.
Should there be a LayerAnimationDelegate::GetCompositor(), so that the animator
can get to the right collection to add itself to/remove itself from?

[ajuma, 2014/05/23 19:15:14]

Maybe LayerAnimationDelegate::GetCollection(), where the implementation in Layer
calls into the compositor to get the collection?

Also, if a layer with an active animator is moved from one compositor to
another, we'll need to make sure to remove the animator from the old
compositor's collection and add it to the new one.

+  if (LayerAnimatorCollection::GetInstance()->HasActiveAnimators())
+    host_->SetNeedsAnimate();
+}
+
 void Compositor::Layout() {
   // We're sending damage that will be addressed during this composite
   // cycle, so we don't need to schedule another composite to address it.
   disable_schedule_composite_ = true;
   if (root_layer_)
     root_layer_->SendDamagedRects();
   disable_schedule_composite_ = false;
 }
 
 scoped_ptr<cc::OutputSurface> Compositor::CreateOutputSurface(bool fallback) {
@@ skipping 99 matching lines @@
     // CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
 }  // namespace ui