cc: Split animating and drawing into separate actions

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 <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 435 matching lines @@
 void ThreadProxy::SetNeedsBeginImplFrame(bool enable) {
   TRACE_EVENT1("cc", "ThreadProxy::SetNeedsBeginImplFrame", "enable", enable);
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->SetNeedsBeginImplFrame(enable);
   UpdateBackgroundAnimateTicking();
 }
 
 void ThreadProxy::BeginImplFrame(const BeginFrameArgs& args) {
   TRACE_EVENT0("cc", "ThreadProxy::BeginImplFrame");
   DCHECK(IsImplThread());
-
-  // Sample the frame time now. This time will be used for updating animations
-  // when we draw.
-  impl().layer_tree_host_impl->UpdateCurrentFrameTime();
-
   impl().scheduler->BeginImplFrame(args);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   DCHECK(IsImplThread());
   impl().scheduler->SetCanDraw(can_draw);
   UpdateBackgroundAnimateTicking();
 }
@@ skipping 111 matching lines @@
   DCHECK(IsMainThread());
   return main().commit_request_sent_to_impl_thread;
 }
 
 void ThreadProxy::SetNeedsRedrawOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedrawOnImplThread");
   DCHECK(IsImplThread());
   impl().scheduler->SetNeedsRedraw();
 }
 
+void ThreadProxy::SetNeedsAnimateOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsAnimateOnImplThread");
+  DCHECK(IsImplThread());
+  impl().scheduler->SetNeedsAnimate();
+}
+
 void ThreadProxy::SetNeedsManageTilesOnImplThread() {
   DCHECK(IsImplThread());
   impl().scheduler->SetNeedsManageTiles();
 }
 
 void ThreadProxy::SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) {
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->SetViewportDamage(damage_rect);
   SetNeedsRedrawOnImplThread();
 }
@@ skipping 444 matching lines @@
   DCHECK(impl().scheduler);
   DCHECK(impl().scheduler->CommitPending());
   DCHECK(!impl().layer_tree_host_impl->pending_tree());
 
   if (did_handle)
     SetInputThrottledUntilCommitOnImplThread(false);
   impl().layer_tree_host_impl->BeginMainFrameAborted(did_handle);
   impl().scheduler->BeginMainFrameAborted(did_handle);
 }
 
+void ThreadProxy::ScheduledActionAnimate() {
+  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionAnimate");
+  DCHECK(IsImplThread());
+
+  impl().layer_tree_host_impl->UpdateCurrentFrameTime();

[brianderson, 2014/04/01 16:05:11]

I think we should keep the UpdateCurrentFrameTime() in the BeginImplFrame, so
that even if we animate right before the draw, we are using a timestamp that is
representative of the BeginImplFrame.

[Sami, 2014/04/17 15:16:33]

Yes, agreed. I've changed this back the way it was.

+  UpdateBackgroundAnimateTicking();
+
+  if (!impl().animations_frozen_until_next_draw) {
+    impl().animation_time =
+        impl().layer_tree_host_impl->CurrentFrameTimeTicks();
+  }
+  impl().layer_tree_host_impl->Animate(impl().animation_time);
+}
+
 void ThreadProxy::ScheduledActionCommit() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionCommit");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(impl().commit_completion_event);
   DCHECK(impl().current_resource_update_controller);
 
   // Complete all remaining texture updates.
   impl().current_resource_update_controller->Finalize();
   impl().current_resource_update_controller.reset();
 
   if (impl().animations_frozen_until_next_draw) {
-    impl().animation_freeze_time =
-        std::max(impl().animation_freeze_time,
-                 blocked_main().last_monotonic_frame_begin_time);
+    impl().animation_time = std::max(
+        impl().animation_time, blocked_main().last_monotonic_frame_begin_time);
   }
 
   blocked_main().main_thread_inside_commit = true;
   impl().layer_tree_host_impl->BeginCommit();
   layer_tree_host()->BeginCommitOnImplThread(impl().layer_tree_host_impl.get());
   layer_tree_host()->FinishCommitOnImplThread(
       impl().layer_tree_host_impl.get());
   blocked_main().main_thread_inside_commit = false;
 
   bool hold_commit = layer_tree_host()->settings().impl_side_painting &&
@@ skipping 57 matching lines @@
   TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
   DrawSwapReadbackResult result;
 
   DCHECK(IsImplThread());
   DCHECK(impl().layer_tree_host_impl.get());
 
   impl().timing_history.DidStartDrawing();
   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
   base::AutoReset<bool> mark_inside(&impl().inside_draw, true);
 
-  // Advance our animations.
-  base::TimeTicks monotonic_time;
-  if (impl().animations_frozen_until_next_draw)
-    monotonic_time = impl().animation_freeze_time;
-  else
-    monotonic_time = impl().layer_tree_host_impl->CurrentFrameTimeTicks();
-
-  // TODO(enne): This should probably happen post-animate.
-  if (impl().layer_tree_host_impl->pending_tree())
-    impl().layer_tree_host_impl->pending_tree()->UpdateDrawProperties();
-  impl().layer_tree_host_impl->Animate(monotonic_time);
-
   // This method is called on a forced draw, regardless of whether we are able
   // to produce a frame, as the calling site on main thread is blocked until its
   // request completes, and we signal completion here. If CanDraw() is false, we
   // will indicate success=false to the caller, but we must still signal
   // completion to avoid deadlock.
 
   // We guard PrepareToDraw() with CanDraw() because it always returns a valid
   // frame, so can only be used when such a frame is possible. Since
   // DrawLayers() depends on the result of PrepareToDraw(), it is guarded on
   // CanDraw() as well.
@@ skipping 32 matching lines @@
                  DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS &&
              !impl().layer_tree_host_impl->settings().impl_side_painting) {
     // Without impl-side painting, the animated layer that is checkerboarding
     // will continue to checkerboard until the next commit. If this layer
     // continues to move during the commit, it may continue to checkerboard
     // after the commit since the region rasterized during the commit will not
     // match the region that is currently visible; eventually this
     // checkerboarding will be displayed when we force a draw. To avoid this,
     // we freeze animations until we successfully draw.
     impl().animations_frozen_until_next_draw = true;
-    impl().animation_freeze_time = monotonic_time;
   } else {
     DCHECK_NE(DrawSwapReadbackResult::DRAW_SUCCESS, result.draw_result);
   }
   impl().layer_tree_host_impl->DidDrawAllLayers(frame);
 
   bool start_ready_animations = draw_frame;
   impl().layer_tree_host_impl->UpdateAnimationState(start_ready_animations);
 
   // Check for a pending CompositeAndReadback.
   if (drawing_for_readback) {
@@ skipping 110 matching lines @@
   impl().layer_tree_host_impl->ManageTiles();
 }
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwap");
 
   // SchedulerStateMachine::DidDrawIfPossibleCompleted isn't set up to
   // handle DRAW_ABORTED_CANT_DRAW.  Moreover, the scheduler should
   // never generate this call when it can't draw.
   DCHECK(impl().layer_tree_host_impl->CanDraw());
+  if (impl().layer_tree_host_impl->pending_tree())
+    impl().layer_tree_host_impl->pending_tree()->UpdateDrawProperties();

[brianderson, 2014/04/01 16:05:11]

Why was this moved here?

[Sami, 2014/04/17 15:16:33]

Hmm, I was trying to keep it in DrawSwapReadbackInternal. Not sure how it ended
up here. In any case, I think updating the draw properties should happen right
before we draw instead as a part of animation because the potential consumer of
the animation stage, i.e., the main thread, doesn't care about draw properties.

 
   bool forced_draw = false;
   bool swap_requested = true;
   bool readback_requested = false;
   return DrawSwapReadbackInternal(
       forced_draw, swap_requested, readback_requested);
 }
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndSwapForced() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwapForced");
@@ skipping 373 matching lines @@
 
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc