cc: Delete non-impl-side-painting animation freezing logic

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 89 matching lines @@
     ThreadProxy* proxy,
     int layer_tree_host_id,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : layer_tree_host_id(layer_tree_host_id),
       contents_texture_manager(NULL),
       commit_completion_event(NULL),
       completion_event_for_commit_held_on_tree_activation(NULL),
       next_frame_is_newly_committed_frame(false),
       inside_draw(false),
       input_throttled_until_commit(false),
-      animations_frozen_until_next_draw(false),
       did_commit_after_animating(false),
       smoothness_priority_expiration_notifier(
           proxy->ImplThreadTaskRunner(),
           base::Bind(&ThreadProxy::RenewTreePriority, base::Unretained(proxy)),
           base::TimeDelta::FromMilliseconds(
               kSmoothnessTakesPriorityExpirationDelay * 1000)),
       timing_history(rendering_stats_instrumentation),
       weak_factory(proxy) {
 }
 
@@ skipping 60 matching lines @@
   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::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host()->DidLoseOutputSurface();
 
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
@@ skipping 557 matching lines @@
   main().commit_request_sent_to_impl_thread = true;
 
   layer_tree_host()->ApplyScrollAndScale(
       begin_main_frame_state->scroll_info.get());
 
   layer_tree_host()->WillBeginMainFrame();
 
   layer_tree_host()->BeginMainFrame(begin_main_frame_state->begin_frame_args);
   layer_tree_host()->AnimateLayers(
       begin_main_frame_state->begin_frame_args.frame_time);
-  blocked_main().last_monotonic_frame_begin_time =
-      begin_main_frame_state->begin_frame_args.frame_time;
 
   // Unlink any backings that the impl thread has evicted, so that we know to
   // re-paint them in UpdateLayers.
   if (blocked_main().contents_texture_manager()) {
     blocked_main().contents_texture_manager()->UnlinkAndClearEvictedBackings();
 
     blocked_main().contents_texture_manager()->SetMaxMemoryLimitBytes(
         begin_main_frame_state->memory_allocation_limit_bytes);
     blocked_main().contents_texture_manager()->SetExternalPriorityCutoff(
         begin_main_frame_state->memory_allocation_priority_cutoff);
@@ skipping 150 matching lines @@
   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());
 
-  if (!impl().animations_frozen_until_next_draw) {
-    impl().animation_time =
-        impl().layer_tree_host_impl->CurrentBeginFrameArgs().frame_time;
-  }
+  impl().animation_time =
+      impl().layer_tree_host_impl->CurrentBeginFrameArgs().frame_time;
   impl().layer_tree_host_impl->Animate(impl().animation_time);
   impl().did_commit_after_animating = false;
 }
 
 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 = nullptr;
 
-  if (impl().animations_frozen_until_next_draw) {
-    impl().animation_time = std::max(
-        impl().animation_time, blocked_main().last_monotonic_frame_begin_time);
-  }
   impl().did_commit_after_animating = true;
 
   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 82 matching lines @@
     result = impl().layer_tree_host_impl->PrepareToDraw(&frame);
     draw_frame = forced_draw || result == DRAW_SUCCESS;
   } else {
     result = DRAW_ABORTED_CANT_DRAW;
   }
 
   if (draw_frame) {
     impl().layer_tree_host_impl->DrawLayers(
         &frame, impl().scheduler->LastBeginImplFrameTime());
     result = DRAW_SUCCESS;
-    impl().animations_frozen_until_next_draw = false;
-  } else if (result == 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;
   } else {
     DCHECK_NE(DRAW_SUCCESS, result);
   }
   impl().layer_tree_host_impl->DidDrawAllLayers(frame);
 
   bool start_ready_animations = draw_frame;
   impl().layer_tree_host_impl->UpdateAnimationState(start_ready_animations);
 
   if (draw_frame) {
     bool did_request_swap = impl().layer_tree_host_impl->SwapBuffers(frame);
@@ skipping 307 matching lines @@
 
   impl().timing_history.DidActivateSyncTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc