Fix double ripple on activated flood fill ripple

ui/views/animation/test/test_ink_drop_animation_observer_helper.h

 // 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.
 #ifndef UI_VIEWS_ANIMATION_TEST_TEST_INK_DROP_ANIMATION_OBSERVER_H_
 #define UI_VIEWS_ANIMATION_TEST_TEST_INK_DROP_ANIMATION_OBSERVER_H_
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 30 matching lines @@
 
   ContextType last_animation_ended_context() const {
     return last_animation_ended_context_;
   }
 
   InkDropAnimationEndedReason last_animation_ended_reason() const {
     return last_animation_ended_reason_;
   }
 
   void OnAnimationStarted(ContextType context) {
+    animation_started_contexts_.push_back(context);
     last_animation_started_context_ = context;
     last_animation_started_ordinal_ = GetNextOrdinal();
   }
 
   void OnAnimationEnded(ContextType context,
                         InkDropAnimationEndedReason reason) {
+    animation_ended_contexts_.push_back(context);
     last_animation_ended_context_ = context;
     last_animation_ended_ordinal_ = GetNextOrdinal();
     last_animation_ended_reason_ = reason;
   }
 
   //
   // Collection of assertion predicates to be used with GTest test assertions.
   // i.e. EXPECT_TRUE/EXPECT_FALSE and the ASSERT_ counterparts.
   //
   // Example:
@@ skipping 36 matching lines @@
 
   // Passes *_TRUE assertions when an AnimationEnded() event has NOT been
   // observed.
   testing::AssertionResult AnimationHasNotEnded() {
     if (last_animation_ended_ordinal() < 0)
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << "Animations were ended at ordinal="
                                        << last_animation_ended_ordinal() << ".";
   }
 
+  // Passes *_TRUE assertions when |animation_started_context_| is the same as
+  // |expected_contexts|.
+  testing::AssertionResult AnimationStartedContextsMatch(
+      const std::vector<ContextType>& expected_contexts) {
+    return ContextsMatch(expected_contexts, animation_started_contexts_);
+  }
+
+  // Passes *_TRUE assertions when |animation_ended_context_| is the same as
+  // |expected_contexts|.
+  testing::AssertionResult AnimationEndedContextsMatch(
+      const std::vector<ContextType>& expected_contexts) {
+    return ContextsMatch(expected_contexts, animation_ended_contexts_);
+  }
+
  private:
+  // Helper function that checks if |actual_contexts| is the same as
+  // |expected_contexts| returning appropriate AssertionResult.
+  testing::AssertionResult ContextsMatch(
+      const std::vector<ContextType>& expected_contexts,
+      const std::vector<ContextType>& actual_contexts) {
+    const bool match =
+        expected_contexts.size() == actual_contexts.size() &&
+        std::equal(expected_contexts.begin(), expected_contexts.end(),
+                   actual_contexts.begin());
+    testing::AssertionResult result =
+        match ? (testing::AssertionSuccess() << "Expected == Actual: {")
+              : (testing::AssertionFailure() << "Expected != Actual: {");
+    for (auto eit = expected_contexts.begin(), ait = actual_contexts.begin();
+         eit != expected_contexts.end() || ait != actual_contexts.end();) {
+      if (eit != expected_contexts.begin())
+        result << ", ";
+      const bool eexists = eit != expected_contexts.end();
+      const bool aexists = ait != actual_contexts.end();
+      const bool item_match = eexists && aexists && *eit == *ait;
+      result << (eexists ? ToString(*eit) : "<none>")
+             << (item_match ? " == " : " != ")
+             << (aexists ? ToString(*ait) : "<none>");
+      if (eexists)
+        eit++;
+      if (aexists)
+        ait++;
+    }
+    result << "}";
+    return result;
+  }
+
   // Returns the next event ordinal. The first returned ordinal will be 1.
   int GetNextOrdinal() const {
     return std::max(1, std::max(last_animation_started_ordinal_,
                                 last_animation_ended_ordinal_) +
                            1);
   }
 
   // The ordinal time of the last AnimationStarted() call.
   int last_animation_started_ordinal_;
 
+  // List of contexts for which animation is started.
+  std::vector<ContextType> animation_started_contexts_;
+
   // The |context| passed to the last call to AnimationStarted().
   ContextType last_animation_started_context_;
 
   // The ordinal time of the last AnimationEnded() call.
   int last_animation_ended_ordinal_;
 
+  // List of contexts for which animation is ended.
+  std::vector<ContextType> animation_ended_contexts_;
+
   // The |context| passed to the last call to AnimationEnded().
   ContextType last_animation_ended_context_;
 
   InkDropAnimationEndedReason last_animation_ended_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(TestInkDropAnimationObserverHelper);
 };
 
 }  // namespace test
 }  // namespace views
 
 #endif  // UI_VIEWS_ANIMATION_TEST_TEST_INK_DROP_ANIMATION_OBSERVER_H_