Remove gfx::FrameTime for a single clock source

ui/compositor/layer_animator_unittest.cc

 // Copyright (c) 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 "ui/compositor/layer_animator.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator_collection.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 #include "ui/compositor/test/layer_animator_test_controller.h"
 #include "ui/compositor/test/test_compositor_host.h"
 #include "ui/compositor/test/test_layer_animation_delegate.h"
 #include "ui/compositor/test/test_layer_animation_observer.h"
 #include "ui/compositor/test/test_utils.h"
-#include "ui/gfx/frame_time.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace ui {
 
 namespace {
 
 // Converts |color| to a string. Each component of the color is separated by a
 // space and the order if A R G B.
 std::string ColorToString(SkColor color) {
@@ skipping 150 matching lines @@
 } // namespace
 
 // Checks that setting a property on an implicit animator causes an animation to
 // happen.
 TEST(LayerAnimatorTest, ImplicitAnimation) {
   scoped_refptr<LayerAnimator> animator(
       LayerAnimator::CreateImplicitAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
-  base::TimeTicks now = gfx::FrameTime::Now();
+  base::TimeTicks now = base::TimeTicks::Now();
   animator->SetBrightness(0.5);
   EXPECT_TRUE(animator->is_animating());
   animator->Step(now + base::TimeDelta::FromSeconds(1));
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 }
 
 // Checks that if the animator is a default animator, that implicit animations
 // are not started.
 TEST(LayerAnimatorTest, NoImplicitAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
@@ skipping 827 matching lines @@
           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
                                                         delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)
       ));
 
   // If last step time was not set correctly, the resulting delta should be
   // miniscule (fractions of a millisecond). If set correctly, then the delta
   // should be enormous. Arbitrarily choosing 1 minute as the threshold,
   // though a much smaller value would probably have sufficed.
-  delta = gfx::FrameTime::Now() - animator->last_step_time();
+  delta = base::TimeTicks::Now() - animator->last_step_time();
   EXPECT_GT(60.0, delta.InSecondsF());
 }
 
 //-------------------------------------------------------
 // Preempt by immediately setting new target.
 TEST(LayerAnimatorTest, MultiPreemptBySettingNewTarget) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
@@ skipping 579 matching lines @@
   TestLayerAnimator* animator = new TestLayerAnimator();
   LayerAnimatorDestructionObserver destruction_observer;
   animator->SetDestructionObserver(&destruction_observer);
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   {
     // ScopedLayerAnimationSettings should keep the Animator alive as long as
     // it is alive, even beyond the end of the animation.
     ScopedLayerAnimationSettings settings(animator);
-    base::TimeTicks now = gfx::FrameTime::Now();
+    base::TimeTicks now = base::TimeTicks::Now();
     animator->SetBrightness(0.5);
     animator->Step(now + base::TimeDelta::FromSeconds(1));
     EXPECT_FALSE(destruction_observer.IsAnimatorDeleted());
   }
   // ScopedLayerAnimationSettings was destroyed, so Animator should be deleted.
   EXPECT_TRUE(destruction_observer.IsAnimatorDeleted());
 }
 
 // Tests that an observer added to a scoped settings object is not notified
 // when the animator is destroyed unless explicitly requested.
@@ skipping 988 matching lines @@
   EXPECT_TRUE(animator->is_animating());
   animator->Step(animator->last_step_time() +
                  base::TimeDelta::FromMilliseconds(500));
   animator->StopAnimating();
 
   EXPECT_EQ(nullptr, observer.animator_layer());
   EXPECT_TRUE(animator->is_animating());
 }
 
 }  // namespace ui