Add MD Ink Drop Layers to InkDropHost only when a ripple/hover is active.

ui/views/animation/ink_drop_animation_controller_impl.h

 // 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.
 
 #ifndef UI_VIEWS_ANIMATION_INK_DROP_ANIMATION_CONTROLLER_IMPL_H_
 #define UI_VIEWS_ANIMATION_INK_DROP_ANIMATION_CONTROLLER_IMPL_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/views/animation/ink_drop_animation_controller.h"
 #include "ui/views/animation/ink_drop_animation_observer.h"
+#include "ui/views/animation/ink_drop_hover_observer.h"
 #include "ui/views/views_export.h"
 
 namespace base {
 class Timer;
 }  // namespace base
 
 namespace views {
 namespace test {
 class InkDropAnimationControllerImplTestApi;
 }  // namespace test
 
 class InkDropAnimation;
 class InkDropHost;
 class InkDropHover;
 class InkDropAnimationControllerFactoryTest;
 
 // A functional implementation of an InkDropAnimationController.
 class VIEWS_EXPORT InkDropAnimationControllerImpl
     : public InkDropAnimationController,
-      public InkDropAnimationObserver {
+      public InkDropAnimationObserver,
+      public InkDropHoverObserver {
  public:
   // Constructs an ink drop controller that will attach the ink drop to the
   // given |ink_drop_host|.
   explicit InkDropAnimationControllerImpl(InkDropHost* ink_drop_host);
   ~InkDropAnimationControllerImpl() override;
 
   // InkDropAnimationController:
   InkDropState GetTargetInkDropState() const override;
   bool IsVisible() const override;
   void AnimateToState(InkDropState ink_drop_state) override;
@@ skipping 14 matching lines @@
   // Destroys the current |ink_drop_animation_|.
   void DestroyInkDropAnimation();
 
   // Creates a new InkDropHover and sets it to |hover_|. If |hover_| wasn't null
   // then it will be destroyed using DestroyInkDropHover().
   void CreateInkDropHover();
 
   // Destroys the current |hover_|.
   void DestroyInkDropHover();
 
+  // Conditionally adds the |root_layer_| to the |ink_drop_host_|.
+  void AddRootLayerToHost();

[varkha, 2016/04/28 20:35:00]

MaybeAddRootLayerToHost? Also I think it could be possible to document right
here when that "maybe" is true.

[bruthig, 2016/04/29 11:02:34]

I've opted to use the 'IfNeeded' Suffix.  WDYT?

+
+  // Conditionally removes the |root_layer_| from the |ink_drop_host_|.
+  void RemoveRootLayerFromHost();
+
   // Returns true if the hover animation is in the process of fading in or
   // is visible.
   bool IsHoverFadingInOrVisible() const;
 
   // views::InkDropAnimationObserver:
   void AnimationStarted(InkDropState ink_drop_state) override;
   void AnimationEnded(InkDropState ink_drop_state,
                       InkDropAnimationEndedReason reason) override;
 
+  // views::InkDropHoverObserver:
+  void AnimationStarted(InkDropHover::AnimationType animation_type) override;
+  void AnimationEnded(InkDropHover::AnimationType animation_type,
+                      InkDropAnimationEndedReason reason) override;
+
   // Enables or disables the hover state based on |is_hovered| and if an
   // animation is triggered it will be scheduled to have the given
   // |animation_duration|. If |explode| is true the hover will expand as it
   // fades out. |explode| is ignored when |is_hovered| is true.
   void SetHoveredInternal(bool is_hovered,
                           base::TimeDelta animation_duration,
                           bool explode);
 
   // Starts the |hover_after_animation_timer_| timer. This will stop the current
   // |hover_after_animation_timer_| instance if it exists.
   void StartHoverAfterAnimationTimer();
 
   // Stops and destroys the current |hover_after_animation_timer_| instance.
   void StopHoverAfterAnimationTimer();
 
   // Callback for when the |hover_after_animation_timer_| fires.
   void HoverAfterAnimationTimerFired();
 
   // The host of the ink drop. Used to poll for information such as whether the
   // hover should be shown or not.
   InkDropHost* ink_drop_host_;
 
   // The root Layer that parents the InkDropAnimation layers and the
   // InkDropHover layers. The |root_layer_| is the one that is added and removed
   // from the InkDropHost.
   std::unique_ptr<ui::Layer> root_layer_;
 
+  // True when the |root_layer_| has been added to the |ink_drop_host_|.
+  bool root_layer_added_to_host_;
+
   // The current InkDropHover. Lazily created using CreateInkDropHover();

[varkha, 2016/04/28 20:35:00]

Not sure about it myself and definitely not in this CL but maybe InkDropHover
should be InkDropHoverAnimation and InkDropAnimation should be
InkDropHoverRippleAnimation. alternatively consider simpler InkDropHover and
InkDropRipple. Either will bring the names closer to point the similarities.

[bruthig, 2016/04/29 11:02:34]

100% agreed.  I was thinking InkDropRipple and InkDropHover.  I just didn't want
to do this rename while I was still merging stuff back to M51.

   std::unique_ptr<InkDropHover> hover_;
 
   // Tracks the logical hovered state of |this| as manipulated by the public
   // SetHovered() function.
   bool is_hovered_;
 
   // The current InkDropAnimation. Created on demand using
   // CreateInkDropAnimation().
   std::unique_ptr<InkDropAnimation> ink_drop_animation_;
 
   // The timer used to delay the hover fade in after an ink drop animation.
   std::unique_ptr<base::Timer> hover_after_animation_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(InkDropAnimationControllerImpl);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_ANIMATION_INK_DROP_ANIMATION_CONTROLLER_IMPL_H_