cc : Track opacity animation changes on effect tree

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"
@@ skipping 12 matching lines @@
 TestLayer::TestLayer() {
   ClearMutatedProperties();
 }
 
 void TestLayer::ClearMutatedProperties() {
   transform_ = gfx::Transform();
   opacity_ = 0;
   filters_ = FilterOperations();
   scroll_offset_ = gfx::ScrollOffset();
   transform_is_animating_ = false;
+  has_potential_opacity_animation_ = false;
+  opacity_is_currently_animating_ = false;
 
   for (int i = 0; i <= TargetProperty::LAST_TARGET_PROPERTY; ++i)
     mutated_properties_[i] = false;
 }
 
 int TestLayer::transform_x() const {
   gfx::Vector2dF vec = transform_.To2dTranslation();
   return static_cast<int>(vec.x());
 }
 
@@ skipping 80 matching lines @@
 
 void TestHostClient::ElementTransformIsPotentiallyAnimatingChanged(
     ElementId element_id,
     ElementListType list_type,
     bool is_animating) {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   if (layer)
     layer->set_transform_is_animating(is_animating);
 }
 
+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::SetScrollOffsetForAnimation(
     const gfx::ScrollOffset& scroll_offset) {
   scroll_offset_ = scroll_offset;
 }
 
 gfx::ScrollOffset TestHostClient::GetScrollOffsetForAnimation(
     ElementId element_id) const {
   return scroll_offset_;
 }
 
@@ skipping 59 matching lines @@
   return layer->scroll_offset();
 }
 
 bool TestHostClient::GetTransformIsAnimating(ElementId element_id,
                                              ElementListType list_type) const {
   TestLayer* layer = FindTestLayer(element_id, list_type);
   EXPECT_TRUE(layer);
   return layer->transform_is_animating();
 }
 
+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();
+}
+
+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();
+}
+
 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());
 }
 
 void TestHostClient::ExpectOpacityPropertyMutated(ElementId element_id,
@@ skipping 181 matching lines @@
   return element_animations ? element_animations->players_list().head()->value()
                             : nullptr;
 }
 
 int AnimationTimelinesTest::NextTestLayerId() {
   next_test_layer_id_++;
   return next_test_layer_id_;
 }
 
 }  // namespace cc