Refactoring the way begin frame sources inside scheduler work.

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 162 matching lines @@
                  &completion,
                  visible));
   completion.Wait();
 }
 
 void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
                                          bool visible) {
   TRACE_EVENT0("cc", "ThreadProxy::SetVisibleOnImplThread");
   impl().layer_tree_host_impl->SetVisible(visible);
   impl().scheduler->SetVisible(visible);
-  UpdateBackgroundAnimateTicking();
   completion->Signal();
 }
 
-void ThreadProxy::UpdateBackgroundAnimateTicking() {
-  bool should_background_tick =
-      !impl().scheduler->WillDrawIfNeeded() &&
-      impl().layer_tree_host_impl->active_tree()->root_layer();
-  impl().layer_tree_host_impl->UpdateBackgroundAnimateTicking(
-      should_background_tick);
-  if (should_background_tick)
-    impl().animations_frozen_until_next_draw = false;
-}
-
 void ThreadProxy::DoCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DoCreateAndInitializeOutputSurface");
   DCHECK(IsMainThread());
 
   scoped_ptr<OutputSurface> output_surface =
       layer_tree_host()->CreateOutputSurface();
 
   RendererCapabilities capabilities;
   bool success = !!output_surface;
   if (success) {
@@ skipping 97 matching lines @@
 }
 
 void ThreadProxy::CheckOutputSurfaceStatusOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::CheckOutputSurfaceStatusOnImplThread");
   DCHECK(IsImplThread());
   if (!impl().layer_tree_host_impl->IsContextLost())
     return;
   impl().scheduler->DidLoseOutputSurface();
 }
 
-void ThreadProxy::CommitVSyncParameters(base::TimeTicks timebase,
-                                        base::TimeDelta interval) {
-  impl().scheduler->CommitVSyncParameters(timebase, interval);
-}
-
 void ThreadProxy::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
   impl().scheduler->SetEstimatedParentDrawTime(draw_time);
 }
 
 void ThreadProxy::SetMaxSwapsPendingOnImplThread(int max) {
   impl().scheduler->SetMaxSwapsPending(max);
 }
 
 void ThreadProxy::DidSwapBuffersOnImplThread() {
   impl().scheduler->DidSwapBuffers();
 }
 
 void ThreadProxy::DidSwapBuffersCompleteOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::DidSwapBuffersCompleteOnImplThread");
-  DCHECK(IsImplThread());
   impl().scheduler->DidSwapBuffersComplete();
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::DidCompleteSwapBuffers, main_thread_weak_ptr_));
 }
 
-void ThreadProxy::SetNeedsBeginFrame(bool enable) {
-  TRACE_EVENT1("cc", "ThreadProxy::SetNeedsBeginFrame", "enable", enable);
-  impl().layer_tree_host_impl->SetNeedsBeginFrame(enable);
-  UpdateBackgroundAnimateTicking();
-}
-
-void ThreadProxy::BeginFrame(const BeginFrameArgs& args) {
-  impl().scheduler->BeginFrame(args);
-}
-
 void ThreadProxy::WillBeginImplFrame(const BeginFrameArgs& args) {
   impl().layer_tree_host_impl->WillBeginImplFrame(args);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   DCHECK(IsImplThread());
   impl().scheduler->SetCanDraw(can_draw);
-  UpdateBackgroundAnimateTicking();
 }
 
 void ThreadProxy::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "ThreadProxy::NotifyReadyToActivate");
   impl().scheduler->NotifyReadyToActivate();
 }
 
 void ThreadProxy::SetNeedsCommitOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommitOnImplThread");
   DCHECK(IsImplThread());
@@ skipping 606 matching lines @@
     impl().commit_completion_event->Signal();
     impl().commit_completion_event = NULL;
   }
 
   // Delay this step until afer the main thread has been released as it's
   // often a good bit of work to update the tree and prepare the new frame.
   impl().layer_tree_host_impl->CommitComplete();
 
   SetInputThrottledUntilCommitOnImplThread(false);
 
-  UpdateBackgroundAnimateTicking();
-
   impl().next_frame_is_newly_committed_frame = true;
 
   impl().timing_history.DidCommit();
 }
 
 void ThreadProxy::ScheduledActionUpdateVisibleTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionUpdateVisibleTiles");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->UpdateVisibleTiles();
 }
@@ skipping 247 matching lines @@
       settings.timeout_and_draw_when_animation_checkerboards;
   scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced_ =
       settings.maximum_number_of_failed_draws_before_draw_is_forced_;
   scheduler_settings.using_synchronous_renderer_compositor =
       settings.using_synchronous_renderer_compositor;
   scheduler_settings.throttle_frame_production =
       settings.throttle_frame_production;
   impl().scheduler = Scheduler::Create(this,
                                        scheduler_settings,
                                        impl().layer_tree_host_id,
+                                       impl().layer_tree_host_impl.get(),
                                        ImplThreadTaskRunner());
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
 
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
     CompletionEvent* completion,
     scoped_ptr<OutputSurface> output_surface,
@@ skipping 28 matching lines @@
     impl().layer_tree_host_impl->resource_provider()->Finish();
   completion->Signal();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host()->DeleteContentsTexturesOnImplThread(
       impl().layer_tree_host_impl->resource_provider());
   impl().current_resource_update_controller.reset();
-  impl().layer_tree_host_impl->SetNeedsBeginFrame(false);
   impl().scheduler.reset();
   impl().layer_tree_host_impl.reset();
   impl().weak_factory.InvalidateWeakPtrs();
   impl().contents_texture_manager = NULL;
   completion->Signal();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
 }
@@ skipping 167 matching lines @@
   DCHECK(!impl().layer_tree_host_impl->pending_tree());
 
   if (impl().completion_event_for_commit_held_on_tree_activation) {
     TRACE_EVENT_INSTANT0(
         "cc", "ReleaseCommitbyActivation", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
     impl().completion_event_for_commit_held_on_tree_activation->Signal();
     impl().completion_event_for_commit_held_on_tree_activation = NULL;
   }
 
-  UpdateBackgroundAnimateTicking();
-
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc