Explicit animation support

ui/gfx/compositor/layer_animation_sequence.cc

+// Copyright (c) 2011 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/gfx/compositor/layer_animation_sequence.h"
+
+#include <algorithm>
+
+#include "base/debug/trace_event.h"
+#include "ui/gfx/compositor/layer_animation_delegate.h"
+#include "ui/gfx/compositor/layer_animation_element.h"
+
+namespace ui {
+
+LayerAnimationSequence::LayerAnimationSequence()
+    : is_cyclic_(false),
+      last_element_(0) {
+}
+
+LayerAnimationSequence::LayerAnimationSequence(LayerAnimationElement* element)
+    : is_cyclic_(false),
+      last_element_(0) {
+  AddElement(element);
+}
+
+LayerAnimationSequence::~LayerAnimationSequence() {
+}
+
+void LayerAnimationSequence::Progress(base::TimeDelta elapsed,
+                                      LayerAnimationDelegate* delegate) {
+  TRACE_EVENT0("LayerAnimationSequence", "Progress");

[sky, 2011/10/19 00:06:33]

Early out if empty?

+
+  Elements::size_type current_index = last_element_ % elements_.size();
+  while (true) {
+    if (!is_cyclic_ && last_element_ >= elements_.size())

[sky, 2011/10/19 00:06:33]

If is_cyclic is true, I think this loop is problematic. In particular lets say
there is an animation going, you close the lid on your laptop and open it up the
following day. We're going to do this loop a LOT.
Also, I'm not a fan of while(true) loops, I always get worried it's going to get
stuck and run forever.

+      break;
+
+    if (last_start_ + elements_[current_index]->Duration() >= elapsed)
+      break;
+
+    // let the element we're passing finish.
+    elements_[current_index]->Progress(1.0, delegate);
+    last_start_ += elements_[current_index]->Duration();
+    ++last_element_;
+    current_index = last_element_ % elements_.size();
+  }
+
+  if (is_cyclic_ || last_element_ < elements_.size()) {
+    // calculate t.
+    double t = 1.0;
+    if (elements_[current_index]->Duration() > base::TimeDelta()) {
+      t = (elapsed - last_start_).InMillisecondsF() /
+          elements_[current_index]->Duration().InMillisecondsF();
+    }
+    elements_[current_index]->Progress(t, delegate);
+  }
+
+  if (!is_cyclic_ && elapsed == duration_) {
+    last_element_ = 0;
+    last_start_ = base::TimeDelta::FromMilliseconds(0);
+  }
+}
+
+void LayerAnimationSequence::Abort() {
+  while (last_element_ < elements_.size()) {
+    elements_[last_element_]->Abort();
+    ++last_element_;
+  }
+  last_element_ = 0;
+  last_start_ = base::TimeDelta::FromMilliseconds(0);
+}
+
+void LayerAnimationSequence::AddElement(LayerAnimationElement* element) {
+  // Update duration and properties.
+  duration_ += element->Duration();
+  LayerAnimationElement::AnimatableProperties::const_iterator iter =
+      element->Properties().begin();
+  while (iter != element->Properties().end()) {

[sky, 2011/10/19 00:06:33]

Use a for loop and pull 76 into it.

+    properties_.insert(*iter);
+    ++iter;
+  }
+
+  elements_.push_back(element);
+}
+
+bool LayerAnimationSequence::HasCommonProperty(
+    const LayerAnimationElement::AnimatableProperties& other) const {
+  LayerAnimationElement::AnimatableProperties intersection;
+  std::insert_iterator<LayerAnimationElement::AnimatableProperties> ii(
+      intersection, intersection.begin());
+  std::set_intersection(properties_.begin(), properties_.end(),
+                        other.begin(), other.end(),
+                        ii);
+  return intersection.size() > 0;
+}
+
+}  // namespace ui