Use a bitfield to store animatable properties.

ui/compositor/layer_animation_sequence.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/layer_animation_sequence.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/debug/trace_event.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_observer.h"
 
 namespace ui {
 
 LayerAnimationSequence::LayerAnimationSequence()
-    : is_cyclic_(false),
+    : properties_(LayerAnimationElement::UNKNOWN),
+      is_cyclic_(false),
       last_element_(0),
       waiting_for_group_start_(false),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
       weak_ptr_factory_(this) {
 }
 
 LayerAnimationSequence::LayerAnimationSequence(LayerAnimationElement* element)
-    : is_cyclic_(false),
+    : properties_(LayerAnimationElement::UNKNOWN),
+      is_cyclic_(false),
       last_element_(0),
       waiting_for_group_start_(false),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
       weak_ptr_factory_(this) {
   AddElement(element);
 }
 
 LayerAnimationSequence::~LayerAnimationSequence() {
   FOR_EACH_OBSERVER(LayerAnimationObserver,
@@ skipping 132 matching lines @@
   while (current_index < elements_.size()) {
     elements_[current_index]->Abort(delegate);
     ++current_index;
   }
   last_element_ = 0;
   waiting_for_group_start_ = false;
   NotifyAborted();
 }
 
 void LayerAnimationSequence::AddElement(LayerAnimationElement* element) {
-  properties_.insert(element->properties().begin(),
-                     element->properties().end());
+  properties_ |= element->properties();
   elements_.push_back(make_linked_ptr(element));
 }
 
 bool LayerAnimationSequence::HasConflictingProperty(
-    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);
+    LayerAnimationElement::AnimatableProperties other) const {
+  return (properties_ & other) != LayerAnimationElement::UNKNOWN;
 }
 
 bool LayerAnimationSequence::IsFirstElementThreaded() const {
   if (!elements_.empty())
     return elements_[0]->IsThreaded();
 
   return false;
 }
 
 void LayerAnimationSequence::AddObserver(LayerAnimationObserver* observer) {
   if (!observers_.HasObserver(observer)) {
     observers_.AddObserver(observer);
     observer->AttachedToSequence(this);
   }
 }
 
 void LayerAnimationSequence::RemoveObserver(LayerAnimationObserver* observer) {
   observers_.RemoveObserver(observer);
   observer->DetachedFromSequence(this, true);
 }
 
 void LayerAnimationSequence::OnThreadedAnimationStarted(
     const cc::AnimationEvent& event) {
   if (elements_.empty() || event.group_id != animation_group_id_)
     return;
 
   size_t current_index = last_element_ % elements_.size();
-  const LayerAnimationElement::AnimatableProperties& element_properties =
+  LayerAnimationElement::AnimatableProperties element_properties =
     elements_[current_index]->properties();
   LayerAnimationElement::AnimatableProperty event_property =
       LayerAnimationElement::ToAnimatableProperty(event.target_property);
-  DCHECK(element_properties.find(event_property) != element_properties.end());
+  DCHECK(element_properties & event_property);
   elements_[current_index]->set_effective_start_time(
       base::TimeTicks::FromInternalValue(
           event.monotonic_time * base::Time::kMicrosecondsPerSecond));
 }
 
 void LayerAnimationSequence::OnScheduled() {
   NotifyScheduled();
 }
 
 void LayerAnimationSequence::OnAnimatorDestroyed() {
@@ skipping 42 matching lines @@
 
 LayerAnimationElement* LayerAnimationSequence::CurrentElement() const {
   if (elements_.empty())
     return NULL;
 
   size_t current_index = last_element_ % elements_.size();
   return elements_[current_index].get();
 }
 
 }  // namespace ui