cc: Make animations tick regardless of drawing.

cc/trees/single_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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
 #include "cc/output/context_provider.h"
@@ skipping 241 matching lines @@
     DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     DebugScopedSetImplThread impl(this);
 
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
     layer_tree_host_impl_.reset();
   }
   layer_tree_host_ = NULL;
 }
 
+void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
+  DCHECK(Proxy::IsImplThread());
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(!ShouldComposite());
+}
+
 void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
   layer_tree_host_->ScheduleComposite();
 }
 
 void SingleThreadProxy::DidInitializeVisibleTileOnImplThread() {
   // Impl-side painting only.
   NOTREACHED();
 }
 
 void SingleThreadProxy::SetNeedsCommitOnImplThread() {
@@ skipping 105 matching lines @@
   layer_tree_host_->UpdateLayers(
       queue.get(), layer_tree_host_impl_->memory_allocation_limit_bytes());
 
   layer_tree_host_->WillCommit();
   DoCommit(queue.Pass());
   bool result = DoComposite(offscreen_context_provider, frame_begin_time);
   layer_tree_host_->DidBeginFrame();
   return result;
 }
 
+bool SingleThreadProxy::ShouldComposite() const {
+  DCHECK(Proxy::IsImplThread());
+  return layer_tree_host_impl_->visible() &&
+         layer_tree_host_impl_->CanDraw();
+}
+
 bool SingleThreadProxy::DoComposite(
     scoped_refptr<cc::ContextProvider> offscreen_context_provider,
     base::TimeTicks frame_begin_time) {
   DCHECK(!output_surface_lost_);
   {
     DebugScopedSetImplThread impl(this);
     base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
     layer_tree_host_impl_->resource_provider()->
         set_offscreen_context_provider(offscreen_context_provider);
 
-    if (!layer_tree_host_impl_->visible())
+    // 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.
+    if (!ShouldComposite()) {
+      layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
       return false;
+    }
 
     layer_tree_host_impl_->Animate(base::TimeTicks::Now(), base::Time::Now());
-
-    // 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.
-    if (!layer_tree_host_impl_->CanDraw())
-      return false;
+    layer_tree_host_impl_->UpdateBackgroundAnimateTicking(false);
 
     LayerTreeHostImpl::FrameData frame;
     layer_tree_host_impl_->PrepareToDraw(&frame);
     layer_tree_host_impl_->DrawLayers(&frame, frame_begin_time);
     layer_tree_host_impl_->DidDrawAllLayers(frame);
     output_surface_lost_ = layer_tree_host_impl_->IsContextLost();
 
+    bool start_ready_animations = true;
+    layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
+
     layer_tree_host_impl_->BeginNextFrame();
   }
 
   if (output_surface_lost_) {
     cc::ContextProvider* offscreen_contexts = layer_tree_host_impl_->
         resource_provider()->offscreen_context_provider();
     if (offscreen_contexts)
       offscreen_contexts->VerifyContexts();
     layer_tree_host_->DidLoseOutputSurface();
     return false;
@@ skipping 11 matching lines @@
 
 bool SingleThreadProxy::CommitPendingForTesting() { return false; }
 
 skia::RefPtr<SkPicture> SingleThreadProxy::CapturePicture() {
   // Impl-side painting only.
   NOTREACHED();
   return skia::RefPtr<SkPicture>();
 }
 
 }  // namespace cc