gfx: Add FrameTime and DisplayTime classes

ui/compositor/layer_animation_sequence.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_animation_sequence.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/debug/trace_event.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_observer.h"
+#include "ui/gfx/frame_time.h"
 
 namespace ui {
 
 LayerAnimationSequence::LayerAnimationSequence()
     : is_cyclic_(false),
       last_element_(0),
       waiting_for_group_start_(false),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
       weak_ptr_factory_(this) {
 }
 
 LayerAnimationSequence::LayerAnimationSequence(LayerAnimationElement* element)
     : is_cyclic_(false),
       last_element_(0),
       waiting_for_group_start_(false),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
       weak_ptr_factory_(this) {
   AddElement(element);
 }
 
 LayerAnimationSequence::~LayerAnimationSequence() {
   FOR_EACH_OBSERVER(LayerAnimationObserver,
                     observers_,
                     DetachedFromSequence(this, true));
 }
 
 void LayerAnimationSequence::Start(LayerAnimationDelegate* delegate) {
-  DCHECK(start_time_ != base::TimeTicks());
+  DCHECK(start_time_ != gfx::FrameTime());
   last_progressed_fraction_ = 0.0;
   if (elements_.empty())
     return;
 
   elements_[0]->set_requested_start_time(start_time_);
   elements_[0]->Start(delegate, animation_group_id_);
 }
 
-void LayerAnimationSequence::Progress(base::TimeTicks now,
+void LayerAnimationSequence::Progress(gfx::FrameTime now,
                                       LayerAnimationDelegate* delegate) {
-  DCHECK(start_time_ != base::TimeTicks());
+  DCHECK(start_time_ != gfx::FrameTime());
   bool redraw_required = false;
 
   if (elements_.empty())
     return;
 
   if (last_element_ == 0)
     last_start_ = start_time_;
 
   size_t current_index = last_element_ % elements_.size();
   base::TimeDelta element_duration;
@@ skipping 32 matching lines @@
     delegate->ScheduleDrawForAnimation();
 
   if (!is_cyclic_ && last_element_ == elements_.size()) {
     last_element_ = 0;
     waiting_for_group_start_ = false;
     animation_group_id_ = 0;
     NotifyEnded();
   }
 }
 
-bool LayerAnimationSequence::IsFinished(base::TimeTicks time) {
+bool LayerAnimationSequence::IsFinished(gfx::FrameTime time) {
   if (is_cyclic_ || waiting_for_group_start_)
     return false;
 
   if (elements_.empty())
     return true;
 
   if (last_element_ == 0)
     last_start_ = start_time_;
 
-  base::TimeTicks current_start = last_start_;
+  gfx::FrameTime current_start = last_start_;
   size_t current_index = last_element_;
   base::TimeDelta element_duration;
   while (current_index < elements_.size()) {
     elements_[current_index]->set_requested_start_time(current_start);
     if (!elements_[current_index]->IsFinished(time, &element_duration))
       break;
 
     current_start += element_duration;
     ++current_index;
   }
@@ skipping 89 matching lines @@
   if (elements_.empty() || event.group_id != animation_group_id_)
     return;
 
   size_t current_index = last_element_ % elements_.size();
   const LayerAnimationElement::AnimatableProperties& element_properties =
     elements_[current_index]->properties();
   LayerAnimationElement::AnimatableProperty event_property =
       LayerAnimationElement::ToAnimatableProperty(event.target_property);
   DCHECK(element_properties.find(event_property) != element_properties.end());
   elements_[current_index]->set_effective_start_time(
-      base::TimeTicks::FromInternalValue(
-          event.monotonic_time * base::Time::kMicrosecondsPerSecond));
+      gfx::FrameTime::Unsafe_FromSecondsF(event.monotonic_time));
 }
 
 void LayerAnimationSequence::OnScheduled() {
   NotifyScheduled();
 }
 
 void LayerAnimationSequence::OnAnimatorDestroyed() {
   if (observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationObserver>::Iterator it(observers_);
     LayerAnimationObserver* obs;
@@ skipping 39 matching lines @@
 
 LayerAnimationElement* LayerAnimationSequence::CurrentElement() const {
   if (elements_.empty())
     return NULL;
 
   size_t current_index = last_element_ % elements_.size();
   return elements_[current_index].get();
 }
 
 }  // namespace ui