Add logging for |old_ink_drop_state| when ink drop DCHECKs fail.

ui/views/animation/flood_fill_ink_drop_ripple.cc

 // Copyright 2016 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 "ui/views/animation/flood_fill_ink_drop_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 191 matching lines @@
         AnimateToOpacity(kHiddenOpacity, GetAnimationDuration(HIDDEN_FADE_OUT),
                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                          gfx::Tween::EASE_IN_OUT, animation_observer);
         const gfx::Transform transform = CalculateTransform(kMinRadius);
         AnimateToTransform(transform, GetAnimationDuration(HIDDEN_TRANSFORM),
                            ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                            gfx::Tween::EASE_IN_OUT, animation_observer);
       }
       break;
     case InkDropState::ACTION_PENDING: {
-      DCHECK(old_ink_drop_state == InkDropState::HIDDEN);
+      DCHECK_EQ(InkDropState::HIDDEN, old_ink_drop_state)
+          << " old_ink_drop_state=" << ToString(old_ink_drop_state);

[msw, 2017/01/18 23:37:08]

q: won't DCHECK_EQ already print the actual value when it doesn't match the
expected value? (ditto for other DCHECK instances you've changed to DCHECK_EQ),
these are fine if it's extra helpful to have the human-readable ToString() value
printed, but perhaps just DCHECK_EQ is enough.

[bruthig, 2017/01/18 23:53:17]

You're right it will print the int values.  e.g. "(0 vs 1)" but I'm of the
opinion that human readable is better.

 
       AnimateToOpacity(visible_opacity_,
                        GetAnimationDuration(ACTION_PENDING_FADE_IN),
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN, animation_observer);
       PauseOpacityAnimation(GetAnimationDuration(ACTION_PENDING_TRANSFORM) -
                                 GetAnimationDuration(ACTION_PENDING_FADE_IN),
                             ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                             animation_observer);
 
       AnimateToTransform(GetMaxSizeTargetTransform(),
                          GetAnimationDuration(ACTION_PENDING_TRANSFORM),
                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                          gfx::Tween::FAST_OUT_SLOW_IN, animation_observer);
       break;
     }
     case InkDropState::ACTION_TRIGGERED: {
       DCHECK(old_ink_drop_state == InkDropState::HIDDEN ||
-             old_ink_drop_state == InkDropState::ACTION_PENDING);
+             old_ink_drop_state == InkDropState::ACTION_PENDING)
+          << " old_ink_drop_state=" << ToString(old_ink_drop_state);

[msw, 2017/01/18 23:37:08]

(this one is ok, since it's not a DCHECK_EQ)

       if (old_ink_drop_state == InkDropState::HIDDEN) {
         AnimateStateChange(old_ink_drop_state, InkDropState::ACTION_PENDING,
                            animation_observer);
       }
       AnimateToOpacity(kHiddenOpacity,
                        GetAnimationDuration(ACTION_TRIGGERED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
     }
     case InkDropState::ALTERNATE_ACTION_PENDING: {
-      DCHECK(old_ink_drop_state == InkDropState::ACTION_PENDING);
+      DCHECK_EQ(InkDropState::ACTION_PENDING, old_ink_drop_state)
+          << " old_ink_drop_state=" << ToString(old_ink_drop_state);
       AnimateToOpacity(visible_opacity_,
                        GetAnimationDuration(ALTERNATE_ACTION_PENDING),
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN, animation_observer);
       AnimateToTransform(GetMaxSizeTargetTransform(),
                          GetAnimationDuration(ALTERNATE_ACTION_PENDING),
                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                          gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
     }
     case InkDropState::ALTERNATE_ACTION_TRIGGERED:
-      DCHECK(old_ink_drop_state == InkDropState::ALTERNATE_ACTION_PENDING);
+      DCHECK_EQ(InkDropState::ALTERNATE_ACTION_PENDING, old_ink_drop_state)
+          << " old_ink_drop_state=" << ToString(old_ink_drop_state);
       AnimateToOpacity(kHiddenOpacity, GetAnimationDuration(
                                            ALTERNATE_ACTION_TRIGGERED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
     case InkDropState::ACTIVATED: {
       if (old_ink_drop_state == InkDropState::ACTION_PENDING) {
         // The final state of pending animation is the same as the final state
         // of activated animation. We only need to enqueue a zero-length pause
         // so that animation observers are notified in order.
@@ skipping 157 matching lines @@
       (bounds.bottom_right() - point).Length();
 
   float largest_distance =
       std::max(distance_to_top_left, distance_to_top_right);
   largest_distance = std::max(largest_distance, distance_to_bottom_left);
   largest_distance = std::max(largest_distance, distance_to_bottom_right);
   return largest_distance;
 }
 
 }  // namespace views