CC Animation: Use std::bitset to update animation state.

cc/test/animation_timelines_test_common.cc

 // Copyright 2015 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 "cc/test/animation_timelines_test_common.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 std::unique_ptr<TestLayer> TestLayer::Create() {
   return base::WrapUnique(new TestLayer());
 }
 
 TestLayer::TestLayer() {
   ClearMutatedProperties();
 }
 
+TestLayer::~TestLayer() {}
+
 void TestLayer::ClearMutatedProperties() {
   transform_ = gfx::Transform();
   opacity_ = 0;
   filters_ = FilterOperations();
   scroll_offset_ = gfx::ScrollOffset();
-  has_potential_transform_animation_ = false;
-  transform_is_currently_animating_ = false;
-  has_potential_opacity_animation_ = false;
-  opacity_is_currently_animating_ = false;
-  has_potential_filter_animation_ = false;
-  filter_is_currently_animating_ = false;
 
-  for (int i = 0; i <= TargetProperty::LAST_TARGET_PROPERTY; ++i)
-    mutated_properties_[i] = false;
+  has_potential_animation_.reset();
+  is_currently_animating_.reset();
+  mutated_properties_.reset();
 }
 
 int TestLayer::transform_x() const {
   gfx::Vector2dF vec = transform_.To2dTranslation();
   return static_cast<int>(vec.x());
 }
 
 int TestLayer::transform_y() const {
   gfx::Vector2dF vec = transform_.To2dTranslation();
   return static_cast<int>(vec.y());
@@ skipping 68 matching lines @@
 
 void TestHostClient::SetElementScrollOffsetMutated(
     ElementId element_id,
     ElementListType list_type,
     const gfx::ScrollOffset& scroll_offset) {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   if (layer)
     layer->set_scroll_offset(scroll_offset);
 }
 
-void TestHostClient::ElementTransformIsAnimatingChanged(
+void TestHostClient::ElementIsAnimatingChanged(
     ElementId element_id,
     ElementListType list_type,
-    AnimationChangeType change_type,
-    bool is_animating) {
+    const PropertyAnimationState& mask,
+    const PropertyAnimationState& state) {
   TestLayer* layer = FindTestLayer(element_id, list_type);
-  if (layer) {
-    switch (change_type) {
-      case AnimationChangeType::POTENTIAL:
-        layer->set_has_potential_transform_animation(is_animating);
-        break;
-      case AnimationChangeType::RUNNING:
-        layer->set_transform_is_currently_animating(is_animating);
-        break;
-      case AnimationChangeType::BOTH:
-        layer->set_has_potential_transform_animation(is_animating);
-        layer->set_transform_is_currently_animating(is_animating);
-        break;
-    }
+  if (!layer)
+    return;
+
+  for (int property = TargetProperty::FIRST_TARGET_PROPERTY;
+       property <= TargetProperty::LAST_TARGET_PROPERTY; ++property) {
+    TargetProperty::Type target_property =
+        static_cast<TargetProperty::Type>(property);
+    if (mask.potentially_animating[property])
+      layer->set_has_potential_animation(target_property,
+                                         state.potentially_animating[property]);
+    if (mask.currently_running[property])
+      layer->set_is_currently_animating(target_property,
+                                        state.currently_running[property]);
   }
 }
 
-void TestHostClient::ElementOpacityIsAnimatingChanged(
-    ElementId element_id,
-    ElementListType list_type,
-    AnimationChangeType change_type,
-    bool is_animating) {
-  TestLayer* layer = FindTestLayer(element_id, list_type);
-  if (layer) {
-    switch (change_type) {
-      case AnimationChangeType::POTENTIAL:
-        layer->set_has_potential_opacity_animation(is_animating);
-        break;
-      case AnimationChangeType::RUNNING:
-        layer->set_opacity_is_currently_animating(is_animating);
-        break;
-      case AnimationChangeType::BOTH:
-        layer->set_has_potential_opacity_animation(is_animating);
-        layer->set_opacity_is_currently_animating(is_animating);
-        break;
-    }
-  }
-}
-
-void TestHostClient::ElementFilterIsAnimatingChanged(
-    ElementId element_id,
-    ElementListType list_type,
-    AnimationChangeType change_type,
-    bool is_animating) {
-  TestLayer* layer = FindTestLayer(element_id, list_type);
-  if (layer) {
-    switch (change_type) {
-      case AnimationChangeType::POTENTIAL:
-        layer->set_has_potential_filter_animation(is_animating);
-        break;
-      case AnimationChangeType::RUNNING:
-        layer->set_filter_is_currently_animating(is_animating);
-        break;
-      case AnimationChangeType::BOTH:
-        layer->set_has_potential_filter_animation(is_animating);
-        layer->set_filter_is_currently_animating(is_animating);
-        break;
-    }
-  }
-}
-
 void TestHostClient::SetScrollOffsetForAnimation(
     const gfx::ScrollOffset& scroll_offset) {
   scroll_offset_ = scroll_offset;
 }
 
 gfx::ScrollOffset TestHostClient::GetScrollOffsetForAnimation(
     ElementId element_id) const {
   return scroll_offset_;
 }
 
@@ skipping 57 matching lines @@
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
   return layer->scroll_offset();
 }
 
 bool TestHostClient::GetTransformIsCurrentlyAnimating(
     ElementId element_id,
     ElementListType list_type) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
-  return layer->transform_is_currently_animating();
+  return layer->is_currently_animating(TargetProperty::TRANSFORM);
 }
 
 bool TestHostClient::GetHasPotentialTransformAnimation(
     ElementId element_id,
     ElementListType list_type) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
-  return layer->has_potential_transform_animation();
+  return layer->has_potential_animation(TargetProperty::TRANSFORM);
 }
 
 bool TestHostClient::GetOpacityIsCurrentlyAnimating(
     ElementId element_id,
     ElementListType list_type) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
-  return layer->opacity_is_currently_animating();
+  return layer->is_currently_animating(TargetProperty::OPACITY);
 }
 
 bool TestHostClient::GetHasPotentialOpacityAnimation(
     ElementId element_id,
     ElementListType list_type) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
-  return layer->has_potential_opacity_animation();
+  return layer->has_potential_animation(TargetProperty::OPACITY);
 }
 
 bool TestHostClient::GetFilterIsCurrentlyAnimating(
     ElementId element_id,
     ElementListType list_type) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
-  return layer->filter_is_currently_animating();
+  return layer->is_currently_animating(TargetProperty::FILTER);
 }
 
 bool TestHostClient::GetHasPotentialFilterAnimation(
     ElementId element_id,
     ElementListType list_type) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
-  return layer->has_potential_filter_animation();
+  return layer->has_potential_animation(TargetProperty::FILTER);
 }
 
 void TestHostClient::ExpectFilterPropertyMutated(ElementId element_id,
                                                  ElementListType list_type,
                                                  float brightness) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
   EXPECT_TRUE(layer->is_property_mutated(TargetProperty::FILTER));
   EXPECT_EQ(brightness, layer->brightness());
 }
@@ skipping 222 matching lines @@
   }
 
   return result;
 }
 
 void AnimationTimelinesTest::PushProperties() {
   host_->PushPropertiesTo(host_impl_);
 }
 
 }  // namespace cc