Update from https://crrev.com/306655

cc/trees/layer_tree_host_unittest_animation.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/trees/layer_tree_host.h"
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
@@ skipping 88 matching lines @@
   void AfterTest() override {}
 
  private:
   int num_begin_frames_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback);
 
 // Add a layer animation and confirm that
-// LayerTreeHostImpl::updateAnimationState does get called and continues to
-// get called.
+// LayerTreeHostImpl::UpdateAnimationState does get called.
 class LayerTreeHostAnimationTestAddAnimation
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimation()
-      : num_begin_frames_(0), received_animation_started_notification_(false) {}
+      : update_animation_state_was_called_(false) {}
 
   void BeginTest() override {
     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* host_impl,
                             bool has_unfinished_animation) override {
-    if (!num_begin_frames_) {
-      // The animation had zero duration so LayerTreeHostImpl should no
-      // longer need to animate its layers.
-      EXPECT_FALSE(has_unfinished_animation);
-      num_begin_frames_++;
-      return;
-    }
-
-    if (received_animation_started_notification_) {
-      EXPECT_LT(base::TimeTicks(), start_time_);
-
-      LayerAnimationController* controller_impl =
-          host_impl->active_tree()->root_layer()->layer_animation_controller();
-      Animation* animation_impl =
-          controller_impl->GetAnimation(Animation::Opacity);
-      if (animation_impl)
-        controller_impl->RemoveAnimation(animation_impl->id());
-
-      EndTest();
-    }
+    EXPECT_FALSE(has_unfinished_animation);
+    update_animation_state_was_called_ = true;
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               Animation::TargetProperty target_property,
                               int group) override {
-    received_animation_started_notification_ = true;
-    start_time_ = monotonic_time;
-    if (num_begin_frames_) {
-      EXPECT_LT(base::TimeTicks(), start_time_);
+    EXPECT_LT(base::TimeTicks(), monotonic_time);
 
-      LayerAnimationController* controller =
-          layer_tree_host()->root_layer()->layer_animation_controller();
-      Animation* animation =
-          controller->GetAnimation(Animation::Opacity);
-      if (animation)
-        controller->RemoveAnimation(animation->id());
+    LayerAnimationController* controller =
+        layer_tree_host()->root_layer()->layer_animation_controller();
+    Animation* animation = controller->GetAnimation(Animation::Opacity);
+    if (animation)
+      controller->RemoveAnimation(animation->id());
 
-      EndTest();
-    }
+    EndTest();
   }
 
-  void AfterTest() override {}
+  void AfterTest() override { EXPECT_TRUE(update_animation_state_was_called_); }
 
  private:
-  int num_begin_frames_;
-  bool received_animation_started_notification_;
-  base::TimeTicks start_time_;
+  bool update_animation_state_was_called_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAddAnimation);
 
 // Add a layer animation to a layer, but continually fail to draw. Confirm that
 // after a while, we do eventually force a draw.
 class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
@@ skipping 344 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationWithTimingFunction);
 
 // Ensures that main thread animations have their start times synchronized with
 // impl thread animations.
 class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
     : public LayerTreeHostAnimationTest {
  public:
-  LayerTreeHostAnimationTestSynchronizeAnimationStartTimes()
-      : main_start_time_(-1.0),
-        impl_start_time_(-1.0) {}
+  LayerTreeHostAnimationTestSynchronizeAnimationStartTimes() {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
     content_->set_layer_animation_delegate(this);
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
   void BeginTest() override { PostAddAnimationToMainThread(content_.get()); }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               Animation::TargetProperty target_property,
                               int group) override {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->children()[0]->
         layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(Animation::Opacity);
-    main_start_time_ =
-        (animation->start_time() - base::TimeTicks()).InSecondsF();
+    main_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
-
-    if (impl_start_time_ > 0.0)
-      EndTest();
+    EndTest();
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* impl_host,
                             bool has_unfinished_animation) override {
     LayerAnimationController* controller =
         impl_host->active_tree()->root_layer()->children()[0]->
         layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(Animation::Opacity);
     if (!animation)
       return;
 
-    impl_start_time_ =
-        (animation->start_time() - base::TimeTicks()).InSecondsF();
-    controller->RemoveAnimation(animation->id());
-
-    if (main_start_time_ > 0.0)
-      EndTest();
+    impl_start_time_ = animation->start_time();
   }
 
   void AfterTest() override {
-    EXPECT_FLOAT_EQ(impl_start_time_, main_start_time_);
+    EXPECT_EQ(impl_start_time_, main_start_time_);
+    EXPECT_LT(base::TimeTicks(), impl_start_time_);
   }
 
  private:
-  double main_start_time_;
-  double impl_start_time_;
+  base::TimeTicks main_start_time_;
+  base::TimeTicks impl_start_time_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSynchronizeAnimationStartTimes);
 
 // Ensures that notify animation finished is called.
 class LayerTreeHostAnimationTestAnimationFinishedEvents
     : public LayerTreeHostAnimationTest {
@@ skipping 594 matching lines @@
  private:
   scoped_refptr<Layer> content_;
   int num_swap_buffers_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationAfterAnimating);
 
 }  // namespace
 }  // namespace cc