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

cc/test/animation_test_common.h

 // 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.
 
 #ifndef CC_TEST_ANIMATION_TEST_COMMON_H_
 #define CC_TEST_ANIMATION_TEST_COMMON_H_
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_timeline.h"
@@ skipping 63 matching lines @@
   base::TimeDelta duration_;
   float from_;
   float to_;
 };
 
 class FakeLayerAnimationValueObserver : public LayerAnimationValueObserver {
  public:
   FakeLayerAnimationValueObserver();
   ~FakeLayerAnimationValueObserver() override;
 
-  // LayerAnimationValueObserver implementation
-  void OnFilterAnimated(const FilterOperations& filters) override;
-  void OnOpacityAnimated(float opacity) override;
-  void OnTransformAnimated(const gfx::Transform& transform) override;
-  void OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) override;
+  // LayerAnimationValueObserver implementation.
+  void OnFilterAnimated(LayerTreeType tree_type,
+                        const FilterOperations& filters) override;
+  void OnOpacityAnimated(LayerTreeType tree_type, float opacity) override;
+  void OnTransformAnimated(LayerTreeType tree_type,
+                           const gfx::Transform& transform) override;
+  void OnScrollOffsetAnimated(LayerTreeType tree_type,
+                              const gfx::ScrollOffset& scroll_offset) override;
   void OnAnimationWaitingForDeletion() override;
-  void OnTransformIsPotentiallyAnimatingChanged(bool is_animating) override;
-  bool IsActive() const override;
+  void OnTransformIsPotentiallyAnimatingChanged(LayerTreeType tree_type,
+                                                bool is_animating) override;
 
   const FilterOperations& filters() const { return filters_; }
   float opacity() const  { return opacity_; }
   const gfx::Transform& transform() const { return transform_; }
   gfx::ScrollOffset scroll_offset() { return scroll_offset_; }
 
   bool animation_waiting_for_deletion() {
     return animation_waiting_for_deletion_;
   }
 
   bool transform_is_animating() { return transform_is_animating_; }
 
  private:
   FilterOperations filters_;
   float opacity_;
   gfx::Transform transform_;
   gfx::ScrollOffset scroll_offset_;
   bool animation_waiting_for_deletion_;
   bool transform_is_animating_;
 };
 
-class FakeInactiveLayerAnimationValueObserver
-    : public FakeLayerAnimationValueObserver {
+class FakeTypedLayerAnimationValueObserver

[ajuma, 2016/04/14 14:01:18]

Instead of having two fake observers types, can we always just use this one (and
rename it FakeLayerAnimationValueObserver)? The non-typed version seems
confusing (since it ignores tree_type).

[loyso (OOO), 2016/04/15 03:32:21]

The observer (and any observations-related stuff) will go away in next couple of
CLs. I just wanted to save some time and "cut-the-corner". Having just one time
requires more conversion of exisitng tests.
I'll do it if you insist.

[loyso (OOO), 2016/04/15 03:53:27]

Done.

+    : public LayerAnimationValueObserver {
  public:
-  bool IsActive() const override;
+  FakeTypedLayerAnimationValueObserver();
+  ~FakeTypedLayerAnimationValueObserver() override;
+
+  // LayerAnimationValueObserver implementation.
+  void OnFilterAnimated(LayerTreeType tree_type,
+                        const FilterOperations& filters) override;
+  void OnOpacityAnimated(LayerTreeType tree_type, float opacity) override;
+  void OnTransformAnimated(LayerTreeType tree_type,
+                           const gfx::Transform& transform) override;
+  void OnScrollOffsetAnimated(LayerTreeType tree_type,
+                              const gfx::ScrollOffset& scroll_offset) override;
+  void OnAnimationWaitingForDeletion() override;
+  void OnTransformIsPotentiallyAnimatingChanged(LayerTreeType tree_type,
+                                                bool is_animating) override;
+
+  const FilterOperations& filters(LayerTreeType tree_type) const {
+    return filters_[ToIndex(tree_type)];
+  }
+  float opacity(LayerTreeType tree_type) const {
+    return opacity_[ToIndex(tree_type)];
+  }
+  const gfx::Transform& transform(LayerTreeType tree_type) const {
+    return transform_[ToIndex(tree_type)];
+  }
+  gfx::ScrollOffset scroll_offset(LayerTreeType tree_type) {
+    return scroll_offset_[ToIndex(tree_type)];
+  }
+
+  bool animation_waiting_for_deletion() {
+    return animation_waiting_for_deletion_;
+  }
+
+  bool transform_is_animating(LayerTreeType tree_type) {
+    return transform_is_animating_[ToIndex(tree_type)];
+  }
+
+ private:
+  static int ToIndex(LayerTreeType tree_type);
+
+  FilterOperations filters_[2];
+  float opacity_[2];
+  gfx::Transform transform_[2];
+  gfx::ScrollOffset scroll_offset_[2];
+  bool animation_waiting_for_deletion_;
+  bool transform_is_animating_[2];
 };
 
 class FakeLayerAnimationValueProvider : public LayerAnimationValueProvider {
  public:
   gfx::ScrollOffset ScrollOffsetForAnimation() const override;
 
   void set_scroll_offset(const gfx::ScrollOffset& scroll_offset) {
     scroll_offset_ = scroll_offset;
   }
 
@@ skipping 91 matching lines @@
     float end_opacity,
     bool use_timing_function);
 
 void AbortAnimationsOnLayerWithPlayer(int layer_id,
                                       scoped_refptr<AnimationTimeline> timeline,
                                       TargetProperty::Type target_property);
 
 }  // namespace cc
 
 #endif  // CC_TEST_ANIMATION_TEST_COMMON_H_