Merge Compositor's ScrollbarAnimationControllers into single class

cc/input/scrollbar_animation_controller.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_INPUT_SCROLLBAR_ANIMATION_CONTROLLER_H_
 #define CC_INPUT_SCROLLBAR_ANIMATION_CONTROLLER_H_
 
 #include "base/cancelable_callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
@@ skipping 11 matching lines @@
                                                  base::TimeDelta delay) = 0;
   virtual void SetNeedsRedrawForScrollbarAnimation() = 0;
   virtual void SetNeedsAnimateForScrollbarAnimation() = 0;
   virtual void DidChangeScrollbarVisibility() = 0;
   virtual ScrollbarSet ScrollbarsFor(int scroll_layer_id) const = 0;
 
  protected:
   virtual ~ScrollbarAnimationControllerClient() {}
 };
 
-// This abstract class represents the compositor-side analogy of
-// ScrollbarAnimator.  Individual platforms should subclass it to provide
-// specialized implementation.
+// This class fade in scrollbars when scroll and fade out after an idle delay.
+// The fade animations works on both scrollbars and is controlled in this class
 // This class also passes the mouse state to each
 // SingleScrollbarAnimationControllerThinning. The thinning animations are
 // independent between vertical/horizontal and are managed by the
 // SingleScrollbarAnimationControllerThinnings.
 class CC_EXPORT ScrollbarAnimationController {
  public:
-  virtual ~ScrollbarAnimationController();
+  // ScrollbarAnimationController for Android only fade in/out.
+  static std::unique_ptr<ScrollbarAnimationController>
+  CreateScrollbarAnimationControllerLinearFade(
+      int scroll_layer_id,
+      ScrollbarAnimationControllerClient* client,
+      base::TimeDelta delay_before_starting,
+      base::TimeDelta resize_delay_before_starting,
+      base::TimeDelta fade_duration);
+
+  // ScrollbarAnimationController for Desktop Overlay Scrollbar.

[weiliangc, 2017/02/15 19:41:15]

Could you elaborate more about how this is different than Android? Mentioning
this will have the thinning animation and Android won't.

+  static std::unique_ptr<ScrollbarAnimationController>
+  CreateScrollbarAnimationControllerThinning(
+      int scroll_layer_id,
+      ScrollbarAnimationControllerClient* client,
+      base::TimeDelta delay_before_starting,
+      base::TimeDelta resize_delay_before_starting,
+      base::TimeDelta fade_duration,
+      base::TimeDelta thinning_duration);
+
+  ~ScrollbarAnimationController();
+
+  bool ScrollbarsHidden() const;
 
   bool Animate(base::TimeTicks now);
 
-  virtual void DidScrollBegin();
-  virtual void DidScrollUpdate(bool on_resize);
-  virtual void DidScrollEnd();
-  virtual bool ScrollbarsHidden() const;
-  virtual bool NeedThinningAnimation() const;
+  void DidScrollBegin();
+  void DidScrollUpdate(bool on_resize);
+  void DidScrollEnd();
 
   void DidMouseDown();
   void DidMouseUp();
   void DidMouseLeave();
   void DidMouseMoveNear(ScrollbarOrientation, float);
 
   bool mouse_is_over_scrollbar(ScrollbarOrientation orientation) const;
   bool mouse_is_near_scrollbar(ScrollbarOrientation orientation) const;
   bool mouse_is_near_any_scrollbar() const;
 
   void set_mouse_move_distance_for_test(float distance);
 
- protected:
+ private:
   ScrollbarAnimationController(int scroll_layer_id,
                                ScrollbarAnimationControllerClient* client,
                                base::TimeDelta delay_before_starting,
-                               base::TimeDelta resize_delay_before_starting);
+                               base::TimeDelta resize_delay_before_starting,
+                               base::TimeDelta fade_duration);
 
-  virtual void RunAnimationFrame(float progress) = 0;
-  virtual const base::TimeDelta& Duration() = 0;
-  virtual void ApplyOpacityToScrollbars(float opacity) = 0;
+  ScrollbarAnimationController(int scroll_layer_id,
+                               ScrollbarAnimationControllerClient* client,
+                               base::TimeDelta delay_before_starting,
+                               base::TimeDelta resize_delay_before_starting,
+                               base::TimeDelta fade_duration,
+                               base::TimeDelta thinning_duration);
+
+  ScrollbarSet Scrollbars() const;
+  SingleScrollbarAnimationControllerThinning& GetScrollbarAnimationController(
+      ScrollbarOrientation) const;
+
+  // Returns how far through the animation we are as a progress value from
+  // 0 to 1.
+  float AnimationProgressAtTime(base::TimeTicks now);
+  void RunAnimationFrame(float progress);
 
   void StartAnimation();
   void StopAnimation();
-  ScrollbarSet Scrollbars() const;
 
   ScrollbarAnimationControllerClient* client_;
 
   void PostDelayedAnimationTask(bool on_resize);
 
-  int scroll_layer_id() const { return scroll_layer_id_; }
-
-  bool animating_fade() const { return is_animating_; }
-
   bool Captured() const;
 
-  std::unique_ptr<SingleScrollbarAnimationControllerThinning>
-      vertical_controller_;
-  std::unique_ptr<SingleScrollbarAnimationControllerThinning>
-      horizontal_controller_;
-
- private:
-  // Returns how far through the animation we are as a progress value from
-  // 0 to 1.
-  float AnimationProgressAtTime(base::TimeTicks now);
-
-  SingleScrollbarAnimationControllerThinning& GetScrollbarAnimationController(
-      ScrollbarOrientation) const;
+  void ApplyOpacityToScrollbars(float opacity);
 
   base::TimeTicks last_awaken_time_;
   base::TimeDelta delay_before_starting_;
   base::TimeDelta resize_delay_before_starting_;
 
   bool is_animating_;
 
   int scroll_layer_id_;
   bool currently_scrolling_;
   bool scroll_gesture_has_scrolled_;
+
   base::CancelableClosure delayed_scrollbar_fade_;
+  float opacity_;
+  base::TimeDelta fade_duration_;
+
+  bool need_thinning_animation_;

[weiliangc, 2017/02/15 19:41:15]

Make this const to show it is not changed outside constructor.

+  std::unique_ptr<SingleScrollbarAnimationControllerThinning>
+      vertical_controller_;
+  std::unique_ptr<SingleScrollbarAnimationControllerThinning>
+      horizontal_controller_;
 
   base::WeakPtrFactory<ScrollbarAnimationController> weak_factory_;
 };
 
 }  // namespace cc
 
 #endif  // CC_INPUT_SCROLLBAR_ANIMATION_CONTROLLER_H_