CC Animation: Make LayerAnimationController to have just one value observer.

cc/test/animation_test_common.cc

 // Copyright 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 "cc/test/animation_test_common.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
@@ skipping 201 matching lines @@
 }
 
 FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
     : opacity_(0.0f),
       animation_waiting_for_deletion_(false),
       transform_is_animating_(false) {}
 
 FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver() {}
 
 void FakeLayerAnimationValueObserver::OnFilterAnimated(
+    LayerTreeType tree_type,
     const FilterOperations& filters) {
   filters_ = filters;
 }
 
-void FakeLayerAnimationValueObserver::OnOpacityAnimated(float opacity) {
+void FakeLayerAnimationValueObserver::OnOpacityAnimated(LayerTreeType tree_type,
+                                                        float opacity) {
   opacity_ = opacity;
 }
 
 void FakeLayerAnimationValueObserver::OnTransformAnimated(
+    LayerTreeType tree_type,
     const gfx::Transform& transform) {
   transform_ = transform;
 }
 
 void FakeLayerAnimationValueObserver::OnScrollOffsetAnimated(
+    LayerTreeType tree_type,
     const gfx::ScrollOffset& scroll_offset) {
   scroll_offset_ = scroll_offset;
 }
 
 void FakeLayerAnimationValueObserver::OnAnimationWaitingForDeletion() {
   animation_waiting_for_deletion_ = true;
 }
 
 void FakeLayerAnimationValueObserver::OnTransformIsPotentiallyAnimatingChanged(
+    LayerTreeType tree_type,
     bool is_animating) {
   transform_is_animating_ = is_animating;
 }
 
-bool FakeLayerAnimationValueObserver::IsActive() const {
-  return true;
-}
-
-bool FakeInactiveLayerAnimationValueObserver::IsActive() const {
-  return false;
-}
-
 gfx::ScrollOffset FakeLayerAnimationValueProvider::ScrollOffsetForAnimation()
     const {
   return scroll_offset_;
 }
 
+FakeTypedLayerAnimationValueObserver::FakeTypedLayerAnimationValueObserver()
+    : animation_waiting_for_deletion_(false) {
+  opacity_[ToIndex(LayerTreeType::ACTIVE)] = 0.0f;
+  opacity_[ToIndex(LayerTreeType::PENDING)] = 0.0f;
+
+  transform_is_animating_[ToIndex(LayerTreeType::ACTIVE)] = false;
+  transform_is_animating_[ToIndex(LayerTreeType::PENDING)] = false;
+}
+
+FakeTypedLayerAnimationValueObserver::~FakeTypedLayerAnimationValueObserver() {}
+
+int FakeTypedLayerAnimationValueObserver::ToIndex(LayerTreeType tree_type) {
+  int index = static_cast<int>(tree_type);
+  DCHECK_GE(index, 0);
+  DCHECK_LE(index, 1);
+  return index;
+}
+
+void FakeTypedLayerAnimationValueObserver::OnFilterAnimated(
+    LayerTreeType tree_type,
+    const FilterOperations& filters) {
+  filters_[ToIndex(tree_type)] = filters;
+}
+
+void FakeTypedLayerAnimationValueObserver::OnOpacityAnimated(
+    LayerTreeType tree_type,
+    float opacity) {
+  opacity_[ToIndex(tree_type)] = opacity;
+}
+
+void FakeTypedLayerAnimationValueObserver::OnTransformAnimated(
+    LayerTreeType tree_type,
+    const gfx::Transform& transform) {
+  transform_[ToIndex(tree_type)] = transform;
+}
+
+void FakeTypedLayerAnimationValueObserver::OnScrollOffsetAnimated(
+    LayerTreeType tree_type,
+    const gfx::ScrollOffset& scroll_offset) {
+  scroll_offset_[ToIndex(tree_type)] = scroll_offset;
+}
+
+void FakeTypedLayerAnimationValueObserver::OnAnimationWaitingForDeletion() {
+  animation_waiting_for_deletion_ = true;
+}
+
+void FakeTypedLayerAnimationValueObserver::
+    OnTransformIsPotentiallyAnimatingChanged(LayerTreeType tree_type,
+                                             bool is_animating) {
+  transform_is_animating_[ToIndex(tree_type)] = is_animating;
+}
+
 std::unique_ptr<AnimationCurve> FakeFloatTransition::Clone() const {
   return base::WrapUnique(new FakeFloatTransition(*this));
 }
 
 int AddOpacityTransitionToController(LayerAnimationController* controller,
                                      double duration,
                                      float start_opacity,
                                      float end_opacity,
                                      bool use_timing_function) {
   return AddOpacityTransition(controller,
@@ skipping 182 matching lines @@
 void AbortAnimationsOnLayerWithPlayer(int layer_id,
                                       scoped_refptr<AnimationTimeline> timeline,
                                       TargetProperty::Type target_property) {
   LayerAnimationController* controller =
       timeline->animation_host()->GetControllerForLayerId(layer_id);
   DCHECK(controller);
   controller->AbortAnimations(target_property);
 }
 
 }  // namespace cc