compositor: Add rAF-like functionality for the UI.

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"
@@ skipping 70 matching lines @@
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       disable_schedule_composite_(false),
       compositor_lock_(NULL),
       defer_draw_scheduling_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       swap_state_(SWAP_NONE),
       layer_animator_collection_(this),
-      schedule_draw_factory_(this) {
+      weak_ptr_factory_(this) {
   root_web_layer_ = cc::Layer::Create();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
   settings.refresh_rate =
       context_factory_->DoesCreateTestContexts()
       ? kTestRefreshRate
       : kDefaultRefreshRate;
   settings.main_frame_before_draw_enabled = false;
@@ skipping 74 matching lines @@
   context_factory_->RemoveCompositor(this);
 }
 
 void Compositor::ScheduleDraw() {
   if (compositor_thread_loop_) {
     host_->SetNeedsCommit();
   } else if (!defer_draw_scheduling_) {
     defer_draw_scheduling_ = true;
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&Compositor::Draw, schedule_draw_factory_.GetWeakPtr()));
+        base::Bind(&Compositor::Draw, weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
   if (root_layer_ == root_layer)
     return;
   if (root_layer_)
     root_layer_->SetCompositor(NULL);
   root_layer_ = root_layer;
   if (root_layer_ && !root_layer_->GetCompositor())
@@ skipping 86 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) {
-  layer_animator_collection_.Progress(frame_begin_time);
-  if (layer_animator_collection_.HasActiveAnimators())
+  bool should_animate = false;
+  std::set<AnimationFrameTask*> tasks = rafs_;
+  for (std::set<AnimationFrameTask*>::iterator i = tasks.begin();
+       i != tasks.end();
+       ++i) {
+    AnimationFrameTask* task = *i;
+    if (!rafs_.count(task))
+      continue;
+    if (task->Progress(frame_begin_time) == ANIMATION_FRAME_TASK_CONTINUE) {
+      CHECK(rafs_.count(task));

[piman, 2014/07/31 01:17:03]

nit: DCHECK

+      should_animate = true;
+    } else {
+      DCHECK(!rafs_.count(task));
+    }
+  }

[piman, 2014/07/31 01:17:03]

maybe it's naive, but why wouldn't the standard Observer pattern work here?
Replace RequestAnimationFrameTask and RemoveAnimationFrameTask by an
Add/RemoveAnimationObserver (which would add to an ObserverList, and possibly
call SetNeedsAnimate), do a FOR_ALL_OBSERVERS here, and SetNeedsAnimate iff
there is any observer left.

+
+  if (should_animate)
     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;
@@ skipping 48 matching lines @@
       NotifyEnd();
       swap_state_ = SWAP_COMPLETED;
     }
   }
 
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingAborted(this));
 }
 
-void Compositor::ScheduleAnimationForLayerCollection() {
-  host_->SetNeedsAnimate();
-}
-
 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
   return host_->debug_state();
 }
 
 void Compositor::SetLayerTreeDebugState(
     const cc::LayerTreeDebugState& debug_state) {
   host_->SetDebugState(debug_state);
 }
 
 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
@@ skipping 33 matching lines @@
     // Call ScheduleDraw() instead of Draw() in order to allow other
     // CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
+scoped_ptr<ScopedAnimationFrameTask> Compositor::RequestAnimationFrameTask(
+    AnimationFrameTask* task) {
+  CHECK(!rafs_.count(task));
+  rafs_.insert(task);
+  host_->SetNeedsAnimate();
+  return make_scoped_ptr(new ScopedAnimationFrameTask(
+      task,
+      base::Bind(&Compositor::RemoveAnimationFrameTask,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 task)));
+}
+
+void Compositor::RemoveAnimationFrameTask(AnimationFrameTask* task) {
+  CHECK(rafs_.count(task));
+  rafs_.erase(task);
+}
+
 }  // namespace ui