Plumb NotifyAnimationAborted from the compositor to blink animation delegate.

cc/animation/layer_animation_controller_unittest.cc

 // 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.
 
 #include "cc/animation/layer_animation_controller.h"
 
 #include <stddef.h>
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
@@ skipping 1012 matching lines @@
   EXPECT_FALSE(controller_impl->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(controller->scroll_offset_animation_was_interrupted());
 
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(controller_impl->scroll_offset_animation_was_interrupted());
 }
 
 class FakeAnimationDelegate : public AnimationDelegate {
  public:
   FakeAnimationDelegate()
       : started_(false), finished_(false), start_time_(base::TimeTicks()) {}

[ajuma, 2016/01/15 16:49:54]

aborted_ needs to be initialized

 
   void NotifyAnimationStarted(TimeTicks monotonic_time,
                               Animation::TargetProperty target_property,
                               int group) override {
     started_ = true;
     start_time_ = monotonic_time;
   }
 
   void NotifyAnimationFinished(TimeTicks monotonic_time,
                                Animation::TargetProperty target_property,
                                int group) override {
     finished_ = true;
   }
 
+  void NotifyAnimationAborted(TimeTicks monotonic_time,
+                              Animation::TargetProperty target_property,
+                              int group) override {
+    aborted_ = true;
+  }
+
   bool started() { return started_; }
 
   bool finished() { return finished_; }
 
+  bool aborted() { return aborted_; }
+
   TimeTicks start_time() { return start_time_; }
 
  private:
   bool started_;
   bool finished_;
+  bool aborted_;
   TimeTicks start_time_;
 };
 
 // Tests that impl-only animations lead to start and finished notifications
 // on the impl thread controller's animation delegate.
 TEST(LayerAnimationControllerTest,
      NotificationsForImplOnlyAnimationsAreSentToImplThreadDelegate) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
@@ skipping 794 matching lines @@
 // An animation aborted on the impl thread should get deleted on both threads.
 TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
+  FakeAnimationDelegate delegate;
+  controller->set_layer_animation_delegate(&delegate);
 
   int animation_id =
       AddOpacityTransitionToController(controller.get(), 1.0, 0.f, 1.f, false);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
 
   controller_impl->AbortAnimations(Animation::OPACITY);
   EXPECT_EQ(Animation::ABORTED,
             controller_impl->GetAnimation(Animation::OPACITY)->run_state());
   EXPECT_FALSE(dummy.animation_waiting_for_deletion());
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   AnimationEventsVector events;
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
   EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ(AnimationEvent::ABORTED, events[0].type);
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             controller_impl->GetAnimation(Animation::OPACITY)->run_state());
 
   controller->NotifyAnimationAborted(events[0]);
   EXPECT_EQ(Animation::ABORTED,
             controller->GetAnimation(Animation::OPACITY)->run_state());
+  EXPECT_TRUE(delegate.aborted());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             controller->GetAnimation(Animation::OPACITY)->run_state());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(controller->GetAnimationById(animation_id));
@@ skipping 1096 matching lines @@
   EXPECT_FALSE(controller->IsPotentiallyAnimatingProperty(
       Animation::OPACITY, LayerAnimationController::ObserverType::ACTIVE));
   EXPECT_FALSE(controller->IsCurrentlyAnimatingProperty(
       Animation::OPACITY, LayerAnimationController::ObserverType::PENDING));
   EXPECT_FALSE(controller->IsCurrentlyAnimatingProperty(
       Animation::OPACITY, LayerAnimationController::ObserverType::ACTIVE));
 }
 
 }  // namespace
 }  // namespace cc