cc: Use BeginFrameArgs

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 58 matching lines @@
       commit_requested_(false),
       commit_request_sent_to_impl_thread_(false),
       created_offscreen_context_provider_(false),
       layer_tree_host_(layer_tree_host),
       started_(false),
       textures_acquired_(true),
       in_composite_and_readback_(false),
       manage_tiles_pending_(false),
       weak_factory_on_impl_thread_(this),
       weak_factory_(this),
+      previous_frame_had_checkerboard_(false),
       begin_frame_sent_to_main_thread_completion_event_on_impl_thread_(NULL),
       readback_request_on_impl_thread_(NULL),
       commit_completion_event_on_impl_thread_(NULL),
       completion_event_for_commit_held_on_tree_activation_(NULL),
       texture_acquisition_completion_event_on_impl_thread_(NULL),
       next_frame_is_newly_committed_frame_on_impl_thread_(false),
       throttle_frame_production_(
           layer_tree_host->settings().throttle_frame_production),
       begin_frame_scheduling_enabled_(
           layer_tree_host->settings().begin_frame_scheduling_enabled),
@@ skipping 274 matching lines @@
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::DidCompleteSwapBuffers, main_thread_weak_ptr_));
 }
 
 void ThreadProxy::SetNeedsBeginFrameOnImplThread(bool enable) {
   DCHECK(IsImplThread());
   TRACE_EVENT1("cc", "ThreadProxy::SetNeedsBeginFrameOnImplThread",
                "enable", enable);
   layer_tree_host_impl_->SetNeedsBeginFrame(enable);
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(!enable);
+  if (!enable)
+    previous_frame_had_checkerboard_ = false;
 }
 
 void ThreadProxy::BeginFrameOnImplThread(const BeginFrameArgs& args) {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::BeginFrameOnImplThread");
+
+  base::TimeTicks monotonic_time =
+      layer_tree_host_impl_->CurrentFrameTimeTicks();
+  base::Time wall_clock_time = layer_tree_host_impl_->CurrentFrameTime();
+  if (!previous_frame_had_checkerboard_)
+    layer_tree_host_impl_->Animate(monotonic_time, wall_clock_time);
+
   scheduler_on_impl_thread_->BeginFrame(args);
 }
 
+void ThreadProxy::DidFinishBeginFrameOnImplThread() {
+  layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
+  layer_tree_host_impl_->UpdateAnimationState(
+      !previous_frame_had_checkerboard_);
+}
+
 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());
+//  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
+//      !scheduler_on_impl_thread_->WillDrawIfNeeded());
 }
 
 void ThreadProxy::OnHasPendingTreeStateChanged(bool has_pending_tree) {
   DCHECK(IsImplThread());
   TRACE_EVENT1("cc", "ThreadProxy::OnHasPendingTreeStateChanged",
                "has_pending_tree", has_pending_tree);
-  scheduler_on_impl_thread_->SetHasPendingTree(has_pending_tree);
+  scheduler_on_impl_thread_->SetHasTrees(
+      has_pending_tree,
+      layer_tree_host_impl_->active_tree() ?
+          !layer_tree_host_impl_->active_tree()->root_layer() : true);
+
+  if (!has_pending_tree && !deffered_start_commit_on_impl_thread_.is_null()) {
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        deffered_start_commit_on_impl_thread_);
+    deffered_start_commit_on_impl_thread_.Reset();
+  }
 }
 
 void ThreadProxy::SetNeedsCommitOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommitOnImplThread");
   scheduler_on_impl_thread_->SetNeedsCommit();
 }
 
 void ThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events,
@@ skipping 215 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 =
       layer_tree_host_impl_->CurrentPhysicalTimeTicks();
   begin_frame_state->scroll_info =
       layer_tree_host_impl_->ProcessScrollDeltas();
 
   if (!layer_tree_host_impl_->settings().impl_side_painting) {
     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::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::BeginFrameOnMainThread,
                  main_thread_weak_ptr_,
                  base::Passed(&begin_frame_state)));
 
   if (begin_frame_sent_to_main_thread_completion_event_on_impl_thread_) {
     begin_frame_sent_to_main_thread_completion_event_on_impl_thread_->Signal();
@@ skipping 127 matching lines @@
   }
 
   layer_tree_host_->CommitComplete();
   layer_tree_host_->DidBeginFrame();
 }
 
 void ThreadProxy::StartCommitOnImplThread(
     CompletionEvent* completion,
     ResourceUpdateQueue* raw_queue,
     scoped_refptr<cc::ContextProvider> offscreen_context_provider) {
-  scoped_ptr<ResourceUpdateQueue> queue(raw_queue);
-
   TRACE_EVENT0("cc", "ThreadProxy::StartCommitOnImplThread");
   DCHECK(!commit_completion_event_on_impl_thread_);
   DCHECK(IsImplThread() && IsMainThreadBlocked());
   DCHECK(scheduler_on_impl_thread_);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
 
   if (!layer_tree_host_impl_) {
     TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
     completion->Signal();
+
     return;
   }
 
+  // TODO(brianderson): We really shouldn't need this hack.
+  // It's here to fix LayerTreeHostAnimationTestCompositeAndReadbackAnimateCount
+  // It would be an easy way to initiate commits on the main thread before
+  // the pending tree is free though =)
+  if (layer_tree_host_impl_->pending_tree()) {
+    DCHECK(deffered_start_commit_on_impl_thread_.is_null());
+    deffered_start_commit_on_impl_thread_ =
+        base::Bind(&ThreadProxy::StartCommitOnImplThread,
+                   impl_thread_weak_ptr_,
+                   completion,
+                   raw_queue,
+                   offscreen_context_provider);
+    return;
+  }
+
+  scoped_ptr<ResourceUpdateQueue> queue(raw_queue);
+
   if (offscreen_context_provider.get())
     offscreen_context_provider->BindToCurrentThread();
   layer_tree_host_impl_->resource_provider()->
       set_offscreen_context_provider(offscreen_context_provider);
 
   if (layer_tree_host_->contents_texture_manager()) {
     if (layer_tree_host_->contents_texture_manager()->
             LinkedEvictedBackingsExist()) {
       // Clear any uploads we were making to textures linked to evicted
       // resources
@@ skipping 35 matching lines @@
 
   // Complete all remaining texture updates.
   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();
 
-  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
-      !scheduler_on_impl_thread_->WillDrawIfNeeded());
-
   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);
     completion_event_for_commit_held_on_tree_activation_ =
@@ skipping 38 matching lines @@
   result.did_swap = false;
   DCHECK(IsImplThread());
   DCHECK(layer_tree_host_impl_.get());
   if (!layer_tree_host_impl_)
     return result;
 
   DCHECK(layer_tree_host_impl_->renderer());
   if (!layer_tree_host_impl_->renderer())
     return result;
 
+/*
   base::TimeTicks monotonic_time =
-      layer_tree_host_impl_->CurrentFrameTimeTicks();
+    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_->ActivatePendingTreeIfNeeded();
     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);
+*/
 
   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.
 
   // 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.
 
   bool drawing_for_readback = !!readback_request_on_impl_thread_;
   bool can_do_readback = layer_tree_host_impl_->renderer()->CanReadPixels();
 
   LayerTreeHostImpl::FrameData frame;
   bool draw_frame = false;
-  bool start_ready_animations = true;
+//  bool start_ready_animations = true;
 
   if (layer_tree_host_impl_->CanDraw() &&
       (!drawing_for_readback || can_do_readback)) {
     // If it is for a readback, make sure we draw the portion being read back.
     gfx::Rect readback_rect;
     if (drawing_for_readback)
       readback_rect = readback_request_on_impl_thread_->rect;
 
     // Do not start animations if we skip drawing the frame to avoid
     // checkerboarding.
     if (layer_tree_host_impl_->PrepareToDraw(&frame, readback_rect) ||
         forced_draw)
       draw_frame = true;
-    else
-      start_ready_animations = false;
+//    else
+//      start_ready_animations = false;
   }
 
+  previous_frame_had_checkerboard_ = !draw_frame;
+
   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();
     }
     readback_request_on_impl_thread_->completion.Signal();
@@ skipping 97 matching lines @@
 
 ScheduledActionDrawAndSwapResult
 ThreadProxy::ScheduledActionDrawAndSwapForced() {
   return ScheduledActionDrawAndSwapInternal(true);
 }
 
 void ThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
   if (current_resource_update_controller_on_impl_thread_)
     current_resource_update_controller_on_impl_thread_
         ->PerformMoreUpdates(time);
-  layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
 }
 
 base::TimeDelta ThreadProxy::DrawDurationEstimate() {
   base::TimeDelta historical_estimate =
       draw_duration_history_.Percentile(kDrawDurationEstimationPercentile);
   base::TimeDelta padding = base::TimeDelta::FromMicroseconds(
       kDrawDurationEstimatePaddingInMicroseconds);
   return historical_estimate + padding;
 }
 
+void ThreadProxy::PostBeginFrameDeadline(const base::Closure &closure,
+                                         base::TimeTicks deadline) {
+  base::TimeDelta delta = deadline - base::TimeTicks::Now();
+  if (delta <= base::TimeDelta())
+    delta = base::TimeDelta();
+  Proxy::ImplThreadTaskRunner()->PostDelayedTask(FROM_HERE, closure, delta);
+}
+
 void ThreadProxy::ReadyToFinalizeTextureUpdates() {
   DCHECK(IsImplThread());
   scheduler_on_impl_thread_->FinishCommit();
 }
 
 void ThreadProxy::DidCommitAndDrawFrame() {
   DCHECK(IsMainThread());
   if (!layer_tree_host_)
     return;
   layer_tree_host_->DidCommitAndDrawFrame();
@@ skipping 323 matching lines @@
       !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