cc: Avoid updating animations in the background without an active tree

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 <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 220 matching lines @@
                  &completion,
                  visible));
   completion.Wait();
 }
 
 void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
                                          bool visible) {
   TRACE_EVENT0("cc", "ThreadProxy::SetVisibleOnImplThread");
   layer_tree_host_impl_->SetVisible(visible);
   scheduler_on_impl_thread_->SetVisible(visible);
+  UpdateBackgroundAnimateTicking();
+  completion->Signal();
+}
+
+void ThreadProxy::UpdateBackgroundAnimateTicking() {
   layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
-      !scheduler_on_impl_thread_->WillDrawIfNeeded());
-  completion->Signal();
+      !scheduler_on_impl_thread_->WillDrawIfNeeded() &&
+      layer_tree_host_impl_->active_tree()->root_layer());

[enne (OOO), 2013/08/29 00:10:10]

This seems a little redundant.  Scheduler::WillDrawIfNeeded returns
!SchedulerStateMachine::PendingDrawsShouldBeAborted which returns true if
!can_draw.  CanDraw() itself returns false if there's no active root layer. 
Does that just mean that the scheduler state machine hasn't been updated?

[brianderson, 2013/08/29 00:16:04]

It's confusing with all the negations going on. The issue was we were enabling
background ticking when !can_draw, but we shouldn't be if the reason we
!can_draw is that the active_tree's root layer is null.

 }
 
 void ThreadProxy::DoCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DoCreateAndInitializeOutputSurface");
   DCHECK(IsMainThread());
 
   scoped_ptr<OutputSurface> output_surface = first_output_surface_.Pass();
   if (!output_surface)
     output_surface = layer_tree_host_->CreateOutputSurface();
 
@@ skipping 145 matching lines @@
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::BeginFrameOnImplThread");
   scheduler_on_impl_thread_->BeginFrame(args);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   DCHECK(IsImplThread());
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   scheduler_on_impl_thread_->SetCanDraw(can_draw);
-  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
-      !scheduler_on_impl_thread_->WillDrawIfNeeded());
+  UpdateBackgroundAnimateTicking();
 }
 
 void ThreadProxy::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "ThreadProxy::NotifyReadyToActivate");
   scheduler_on_impl_thread_->NotifyReadyToActivate();
 }
 
 void ThreadProxy::SetNeedsCommitOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommitOnImplThread");
@@ skipping 500 matching lines @@
   current_resource_update_controller_on_impl_thread_->Finalize();
   current_resource_update_controller_on_impl_thread_.reset();
 
   layer_tree_host_impl_->BeginCommit();
   layer_tree_host_->BeginCommitOnImplThread(layer_tree_host_impl_.get());
   layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
   layer_tree_host_impl_->CommitComplete();
 
   SetInputThrottledUntilCommitOnImplThread(false);
 
-  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
-      !scheduler_on_impl_thread_->WillDrawIfNeeded());
+  UpdateBackgroundAnimateTicking();
 
   next_frame_is_newly_committed_frame_on_impl_thread_ = true;
 
   if (layer_tree_host_->settings().impl_side_painting &&
       layer_tree_host_->BlocksPendingCommit() &&
       layer_tree_host_impl_->pending_tree()) {
     // For some layer types in impl-side painting, the commit is held until
     // the pending tree is activated.  It's also possible that the
     // pending tree has already activated if there was no work to be done.
     TRACE_EVENT_INSTANT0("cc", "HoldCommit", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 52 matching lines @@
     return result;
 
   base::TimeTicks monotonic_time =
       layer_tree_host_impl_->CurrentFrameTimeTicks();
   base::Time wall_clock_time = layer_tree_host_impl_->CurrentFrameTime();
 
   // 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_->Animate(monotonic_time, wall_clock_time);
-  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(false);
+  UpdateBackgroundAnimateTicking();
 
   base::TimeTicks start_time = base::TimeTicks::HighResNow();
   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
   base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
   // 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.
@@ skipping 26 matching lines @@
       start_ready_animations = false;
   }
 
   if (draw_frame) {
     layer_tree_host_impl_->DrawLayers(
         &frame,
         scheduler_on_impl_thread_->LastBeginFrameOnImplThreadTime());
     result.did_draw = true;
   }
   layer_tree_host_impl_->DidDrawAllLayers(frame);
-
   layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
   // Check for a pending CompositeAndReadback.
   if (readback_request_on_impl_thread_) {
     readback_request_on_impl_thread_->success = false;
     if (draw_frame) {
       layer_tree_host_impl_->Readback(readback_request_on_impl_thread_->pixels,
                                       readback_request_on_impl_thread_->rect);
       readback_request_on_impl_thread_->success =
           !layer_tree_host_impl_->IsContextLost();
@@ skipping 430 matching lines @@
 
   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;
   }
 
+  UpdateBackgroundAnimateTicking();
+
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 }  // namespace cc