Fix scrollbar fade animation scheduling.

cc/trees/thread_proxy.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/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 587 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::FinishAllRenderingOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_->FinishAllRendering();
   completion->Signal();
 }
 
 void ThreadProxy::ScheduledActionSendBeginFrameToMainThread() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionSendBeginFrameToMainThread");
   scoped_ptr<BeginFrameAndCommitState> begin_frame_state(
       new BeginFrameAndCommitState);
-  begin_frame_state->monotonic_frame_begin_time = base::TimeTicks::Now();
+  begin_frame_state->monotonic_frame_begin_time =
+      layer_tree_host_impl_->CurrentPhysicalTimeTicks();
   begin_frame_state->scroll_info =
       layer_tree_host_impl_->ProcessScrollDeltas();
   DCHECK_GT(layer_tree_host_impl_->memory_allocation_limit_bytes(), 0u);
   begin_frame_state->memory_allocation_limit_bytes =
       layer_tree_host_impl_->memory_allocation_limit_bytes();
   Proxy::MainThread()->PostTask(
       base::Bind(&ThreadProxy::BeginFrameOnMainThread,
                  main_thread_weak_ptr_,
                  base::Passed(&begin_frame_state)));
 
@@ skipping 674 matching lines @@
   *picture = layer_tree_host_impl_->CapturePicture();
   completion->Signal();
 }
 
 void ThreadProxy::RenewTreePriority() {
   bool smoothness_takes_priority =
       layer_tree_host_impl_->pinch_gesture_active() ||
       layer_tree_host_impl_->CurrentlyScrollingLayer() ||
       layer_tree_host_impl_->page_scale_animation_active();
 
+  base::TimeTicks now = layer_tree_host_impl_->CurrentPhysicalTimeTicks();
+
   // Update expiration time if smoothness currently takes priority.
   if (smoothness_takes_priority) {
     smoothness_takes_priority_expiration_time_ =
-        base::TimeTicks::Now() +
-        base::TimeDelta::FromMilliseconds(
-            kSmoothnessTakesPriorityExpirationDelay * 1000);
+        now + base::TimeDelta::FromMilliseconds(
+                  kSmoothnessTakesPriorityExpirationDelay * 1000);
   }
 
   // We use the same priority for both trees by default.
   TreePriority priority = SAME_PRIORITY_FOR_BOTH_TREES;
 
   // Smoothness takes priority if expiration time is in the future.
-  if (smoothness_takes_priority_expiration_time_ > base::TimeTicks::Now())
+  if (smoothness_takes_priority_expiration_time_ > now)
     priority = SMOOTHNESS_TAKES_PRIORITY;
 
   // New content always takes priority when the active tree has
   // evicted resources or there is an invalid viewport size.
   if (layer_tree_host_impl_->active_tree()->ContentsTexturesPurged() ||
       layer_tree_host_impl_->active_tree()->ViewportSizeInvalid())
     priority = NEW_CONTENT_TAKES_PRIORITY;
 
   layer_tree_host_impl_->SetTreePriority(priority);
 
   // Notify the the client of this compositor via the output surface.
   // TODO(epenner): Route this to compositor-thread instead of output-surface
   // after GTFO refactor of compositor-thread (http://crbug/170828).
   if (layer_tree_host_impl_->output_surface()) {
     layer_tree_host_impl_->output_surface()->
         UpdateSmoothnessTakesPriority(priority == SMOOTHNESS_TAKES_PRIORITY);
   }
 
-  base::TimeDelta delay =
-      smoothness_takes_priority_expiration_time_ - base::TimeTicks::Now();
+  base::TimeDelta delay = smoothness_takes_priority_expiration_time_ - now;
 
   // Need to make sure a delayed task is posted when we have smoothness
   // takes priority expiration time in the future.
   if (delay <= base::TimeDelta())
     return;
   if (renew_tree_priority_on_impl_thread_pending_)
     return;
 
   Proxy::ImplThread()->PostDelayedTask(
       base::Bind(&ThreadProxy::RenewTreePriorityOnImplThread,
@@ skipping 11 matching lines @@
 }
 
 void ThreadProxy::RequestScrollbarAnimationOnImplThread(base::TimeDelta delay) {
   Proxy::ImplThread()->PostDelayedTask(
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
-  layer_tree_host_impl_->StartScrollbarAnimation(
-      layer_tree_host_impl_->CurrentFrameTimeTicks());
+  layer_tree_host_impl_->StartScrollbarAnimation();
 }
 
 void ThreadProxy::DidActivatePendingTree() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidActivatePendingTreeOnImplThread");
 
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 }
 
 }  // namespace cc