Removing the use of base::Time inside the LayerTreeHost system.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 150 matching lines @@
           new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
     }
 
     // TODO(enne): This should probably happen post-animate.
     if (layer_tree_host_impl_->pending_tree()) {
       layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
       layer_tree_host_impl_->ManageTiles();
     }
 
     layer_tree_host_impl_->Animate(
-        layer_tree_host_impl_->CurrentFrameTimeTicks(),
-        layer_tree_host_impl_->CurrentFrameTime());
+        layer_tree_host_impl_->CurrentFrameTimeTicks());
     layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
     bool start_ready_animations = true;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
     layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
   }
 
   void SetActive(bool active) {
     if (active != time_source_->Active())
       time_source_->SetActive(active);
   }
@@ skipping 207 matching lines @@
   }
   if (EvictedUIResourcesExist()) {
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
         TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   return true;
 }
 
-void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time,
-                                base::Time wall_clock_time) {
+void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time) {
   if (input_handler_client_)
     input_handler_client_->Animate(monotonic_time);
   AnimatePageScale(monotonic_time);
-  AnimateLayers(monotonic_time, wall_clock_time);
+  AnimateLayers(monotonic_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
 void LayerTreeHostImpl::ManageTiles() {
   if (!tile_manager_)
     return;
   if (!tile_priorities_dirty_)
     return;
 
@@ skipping 2223 matching lines @@
   LayerImpl* scroll_layer = OuterViewportScrollLayer()
                                 ? OuterViewportScrollLayer()
                                 : InnerViewportScrollLayer();
 
   gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
 
   if (!unused_delta.IsZero() && (scroll_layer == OuterViewportScrollLayer()))
     InnerViewportScrollLayer()->ScrollBy(unused_delta);
 }
 
-void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {
+void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time) {
   if (!page_scale_animation_)
     return;
 
-  double monotonic_time = (time - base::TimeTicks()).InSecondsF();
+  double blink_monotonic_time =

[ajuma, 2014/03/11 13:29:18]

This time isn't actually sent to Blink (it's sent to cc::PageScaleAnimation), so
using 'blink' in this name seems misleading.

[mithro-old, 2014/03/11 13:31:20]

Why does cc::PageScaleAnimation use a double? 

Is it a case of something leftover from when cc was moved from WebKit in to
chromium?

Should it be converted to use TimeTicks?

[ajuma, 2014/03/11 13:37:05]

Yes to both: it's leftover from the move, and should ideally be using TimeTicks
instead.

+      (monotonic_time - base::TimeTicks()).InSecondsF();
   gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
 
   if (!page_scale_animation_->IsAnimationStarted())
-    page_scale_animation_->StartAnimation(monotonic_time);
+    page_scale_animation_->StartAnimation(blink_monotonic_time);
 
   active_tree_->SetPageScaleDelta(
-      page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
+      page_scale_animation_->PageScaleFactorAtTime(blink_monotonic_time) /
       active_tree_->page_scale_factor());
   gfx::Vector2dF next_scroll =
-      page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
+      page_scale_animation_->ScrollOffsetAtTime(blink_monotonic_time);
 
   ScrollViewportBy(next_scroll - scroll_total);
   SetNeedsRedraw();
 
-  if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
+  if (page_scale_animation_->IsAnimationCompleteAtTime(blink_monotonic_time)) {
     page_scale_animation_.reset();
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
   }
 }
 
 void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
   if (!top_controls_manager_ || !top_controls_manager_->animation())
     return;
   gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
   if (active_tree_->TotalScrollOffset().y() == 0.f)
     return;
   if (scroll.IsZero()) {
     // This may happen on the first animation step. Force redraw otherwise
     // the animation would stop because of no new frames.
     SetNeedsRedraw();
   } else {
     ScrollViewportBy(gfx::ScaleVector2d(
         scroll, 1.f / active_tree_->total_page_scale_factor()));
   }
 }
 
-void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time,
-                                      base::Time wall_clock_time) {
+void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled ||
       animation_registrar_->active_animation_controllers().empty() ||
       !active_tree_->root_layer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
 
-  double monotonic_seconds = (monotonic_time - base::TimeTicks()).InSecondsF();
-
+  double blink_monotonic_time =

[ajuma, 2014/03/11 13:29:18]

Same naming comment as before. While this time is eventually sent to blink (in
AnimationEvents), the initial consumer is cc::LayerAnimationController.

+      (monotonic_time - base::TimeTicks()).InSecondsF();
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter)
-    (*iter).second->Animate(monotonic_seconds);
+    (*iter).second->Animate(blink_monotonic_time);
 
   SetNeedsRedraw();
 }
 
 void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
   if (!settings_.accelerated_animation_enabled ||
       animation_registrar_->active_animation_controllers().empty() ||
       !active_tree_->root_layer())
     return;
 
@@ skipping 136 matching lines @@
     return;
 
   if (global_tile_state_.tree_priority == priority)
     return;
   global_tile_state_.tree_priority = priority;
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::ResetCurrentFrameTimeForNextFrame() {
   current_frame_timeticks_ = base::TimeTicks();
-  current_frame_time_ = base::Time();
 }
 
-void LayerTreeHostImpl::UpdateCurrentFrameTime(base::TimeTicks* ticks,
-                                               base::Time* now) const {
+void LayerTreeHostImpl::UpdateCurrentFrameTime(base::TimeTicks* ticks) const {
   if (ticks->is_null()) {
-    DCHECK(now->is_null());
     *ticks = CurrentPhysicalTimeTicks();
-    *now = base::Time::Now();
   }
 }
 
 base::TimeTicks LayerTreeHostImpl::CurrentFrameTimeTicks() {
-  UpdateCurrentFrameTime(&current_frame_timeticks_, &current_frame_time_);
+  UpdateCurrentFrameTime(&current_frame_timeticks_);
   return current_frame_timeticks_;
 }
 
-base::Time LayerTreeHostImpl::CurrentFrameTime() {
-  UpdateCurrentFrameTime(&current_frame_timeticks_, &current_frame_time_);
-  return current_frame_time_;
-}
-
 base::TimeTicks LayerTreeHostImpl::CurrentPhysicalTimeTicks() const {
   return gfx::FrameTime::Now();
 }
 
 scoped_ptr<base::Value> LayerTreeHostImpl::AsValueWithFrame(
     FrameData* frame) const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   if (this->pending_tree_)
       state->Set("activation_state", ActivationStateAsValue().release());
   state->Set("device_viewport_size",
@@ skipping 140 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc