cc: Allow the main thread to cancel commits

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 72 matching lines @@
       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),
       using_synchronous_renderer_compositor_(
           layer_tree_host->settings().using_synchronous_renderer_compositor),
       inside_draw_(false),
+      can_cancel_commit_(true),
       defer_commits_(false),
       renew_tree_priority_on_impl_thread_pending_(false),
       draw_duration_history_(kDurationHistorySize),
       begin_frame_to_commit_duration_history_(kDurationHistorySize),
       commit_to_activate_duration_history_(kDurationHistorySize) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_);
 }
 
@@ skipping 18 matching lines @@
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     CompletionEvent begin_frame_sent_to_main_thread_completion;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::ForceCommitOnImplThread,
                    impl_thread_weak_ptr_,
                    &begin_frame_sent_to_main_thread_completion));
     begin_frame_sent_to_main_thread_completion.Wait();
   }
+
   in_composite_and_readback_ = true;
   BeginFrameOnMainThread(scoped_ptr<BeginFrameAndCommitState>());
   in_composite_and_readback_ = false;
 
+  // Composite and readback requires a second commit to undo any changes
+  // that it made.
+  can_cancel_commit_ = false;
+
   // Perform a synchronous readback.
   ReadbackRequest request;
   request.rect = rect;
   request.pixels = pixels;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::RequestReadbackOnImplThread,
                    impl_thread_weak_ptr_,
@@ skipping 149 matching lines @@
   if (result == LayerTreeHost::CreateFailedButTryAgain) {
     if (!output_surface_creation_callback_.callback().is_null()) {
       Proxy::MainThreadTaskRunner()->PostTask(
           FROM_HERE, output_surface_creation_callback_.callback());
     }
   } else {
     output_surface_creation_callback_.Cancel();
   }
 }
 
+void ThreadProxy::SendCommitRequestToImplThreadIfNeeded() {
+  DCHECK(IsMainThread());
+  if (commit_request_sent_to_impl_thread_)
+    return;
+  commit_request_sent_to_impl_thread_ = true;
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread,
+                 impl_thread_weak_ptr_));
+}
+
 const RendererCapabilities& ThreadProxy::GetRendererCapabilities() const {
   DCHECK(IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_main_thread_copy_;
 }
 
 void ThreadProxy::SetNeedsAnimate() {
   DCHECK(IsMainThread());
   if (animate_requested_)
     return;
 
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsAnimate");
   animate_requested_ = true;
+  can_cancel_commit_ = false;
+  SendCommitRequestToImplThreadIfNeeded();
+}
 
-  if (commit_request_sent_to_impl_thread_)
-    return;
-  commit_request_sent_to_impl_thread_ = true;
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread,
-                 impl_thread_weak_ptr_));
+void ThreadProxy::SetNeedsUpdateLayers() {
+  DCHECK(IsMainThread());
+  SendCommitRequestToImplThreadIfNeeded();
 }
 
 void ThreadProxy::SetNeedsCommit() {
   DCHECK(IsMainThread());
+  // Unconditionally set here to handle SetNeedsCommit calls during a commit.
+  can_cancel_commit_ = false;
+
   if (commit_requested_)
     return;
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommit");
   commit_requested_ = true;
 
-  if (commit_request_sent_to_impl_thread_)
-    return;
-  commit_request_sent_to_impl_thread_ = true;
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread,
-                 impl_thread_weak_ptr_));
+  SendCommitRequestToImplThreadIfNeeded();
 }
 
 void ThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurfaceOnImplThread");
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::CheckOutputSurfaceStatusOnImplThread,
                  impl_thread_weak_ptr_));
 }
@@ skipping 322 matching lines @@
   // the paint, commit_requested_ will be set to false to allow new commit
   // requests to be scheduled.
   commit_requested_ = true;
   commit_request_sent_to_impl_thread_ = true;
 
   // On the other hand, the AnimationRequested flag needs to be cleared
   // here so that any animation requests generated by the apply or animate
   // callbacks will trigger another frame.
   animate_requested_ = false;
 
-  if (begin_frame_state)
-    layer_tree_host_->ApplyScrollAndScale(*begin_frame_state->scroll_info);
-
   if (!in_composite_and_readback_ && !layer_tree_host_->visible()) {
     commit_requested_ = false;
     commit_request_sent_to_impl_thread_ = false;
 
     TRACE_EVENT0("cc", "EarlyOut_NotVisible");
+    bool did_handle = false;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
-                   impl_thread_weak_ptr_));
+                   impl_thread_weak_ptr_,
+                   did_handle));
     return;
   }
 
+  if (begin_frame_state)
+    layer_tree_host_->ApplyScrollAndScale(*begin_frame_state->scroll_info);
+
   layer_tree_host_->WillBeginFrame();
 
   if (begin_frame_state) {
     layer_tree_host_->UpdateClientAnimations(
         begin_frame_state->monotonic_frame_begin_time);
     layer_tree_host_->AnimateLayers(
         begin_frame_state->monotonic_frame_begin_time);
   }
 
   // Unlink any backings that the impl thread has evicted, so that we know to
   // re-paint them in UpdateLayers.
   if (layer_tree_host_->contents_texture_manager()) {
     layer_tree_host_->contents_texture_manager()->
         UnlinkAndClearEvictedBackings();
   }
 
   layer_tree_host_->Layout();
 
   // Clear the commit flag after updating animations and layout here --- objects
   // that only layout when painted will trigger another SetNeedsCommit inside
   // UpdateLayers.
   commit_requested_ = false;
   commit_request_sent_to_impl_thread_ = false;
+  bool can_cancel_this_commit =
+      can_cancel_commit_ && !in_composite_and_readback_;
+  can_cancel_commit_ = true;
 
   scoped_ptr<ResourceUpdateQueue> queue =
       make_scoped_ptr(new ResourceUpdateQueue);
-  layer_tree_host_->UpdateLayers(
+  bool updated = layer_tree_host_->UpdateLayers(
       queue.get(),
-      begin_frame_state ?
-          begin_frame_state->memory_allocation_limit_bytes : 0u);
+      begin_frame_state ? begin_frame_state->memory_allocation_limit_bytes
+                        : 0u);
 
   // Once single buffered layers are committed, they cannot be modified until
   // they are drawn by the impl thread.
   textures_acquired_ = false;
 
   layer_tree_host_->WillCommit();
-  // Before applying scrolls and calling animate, we set animate_requested_ to
-  // false. If it is true now, it means SetNeedAnimate was called again, but
-  // during a state when commit_request_sent_to_impl_thread_ = true. We need to
-  // force that call to happen again now so that the commit request is sent to
-  // the impl thread.
+
+  if (!updated && can_cancel_this_commit) {
+    TRACE_EVENT0("cc", "EarlyOut_NoUpdates");
+    bool did_handle = true;
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
+                   impl_thread_weak_ptr_,
+                   did_handle));
+
+    // Although the commit is internally aborted, this is because it has been
+    // detected to be a no-op.  From the perspective of an embedder, this commit
+    // went through, and input should no longer be throttled, etc.
+    layer_tree_host_->CommitComplete();
+    layer_tree_host_->DidBeginFrame();
+    return;
+  }
+
+  // Before calling animate, we set animate_requested_ to false. If it is true
+  // now, it means SetNeedAnimate was called again, but during a state when
+  // commit_request_sent_to_impl_thread_ = true. We need to force that call to
+  // happen again now so that the commit request is sent to the impl thread.
   if (animate_requested_) {
     // Forces SetNeedsAnimate to consider posting a commit task.
     animate_requested_ = false;
     SetNeedsAnimate();
   }
 
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
   if (renderer_capabilities_main_thread_copy_.using_offscreen_context3d &&
       layer_tree_host_->needs_offscreen_context()) {
     offscreen_context_provider = layer_tree_host_->client()->
@@ skipping 75 matching lines @@
   current_resource_update_controller_on_impl_thread_ =
       ResourceUpdateController::Create(
           this,
           Proxy::ImplThreadTaskRunner(),
           queue.Pass(),
           layer_tree_host_impl_->resource_provider());
   current_resource_update_controller_on_impl_thread_->PerformMoreUpdates(
       scheduler_on_impl_thread_->AnticipatedDrawTime());
 }
 
-void ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread() {
+void ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread(bool did_handle) {
   TRACE_EVENT0("cc", "ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(scheduler_on_impl_thread_);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
+  DCHECK(!layer_tree_host_impl_->pending_tree());
 
-  scheduler_on_impl_thread_->BeginFrameAbortedByMainThread();
+  // If the begin frame data was handled, then scroll and scale set was applied
+  // by the main thread, so the active tree needs to be updated as if these sent
+  // values were applied and committed.
+  if (did_handle)
+    layer_tree_host_impl_->active_tree()->ApplySentScrollAndScaleDeltas();
+  scheduler_on_impl_thread_->BeginFrameAbortedByMainThread(did_handle);
 }
 
 void ThreadProxy::ScheduledActionCommit() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionCommit");
   DCHECK(IsImplThread());
   DCHECK(commit_completion_event_on_impl_thread_);
   DCHECK(current_resource_update_controller_on_impl_thread_);
 
   // Complete all remaining texture updates.
   current_resource_update_controller_on_impl_thread_->Finalize();
@@ skipping 47 matching lines @@
 void ThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   DCHECK(IsImplThread());
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::CreateAndInitializeOutputSurface,
                  main_thread_weak_ptr_));
 }
 
 ScheduledActionDrawAndSwapResult
 ThreadProxy::ScheduledActionDrawAndSwapInternal(bool forced_draw) {
-  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwap");
+  TRACE_EVENT1(
+      "cc", "ThreadProxy::ScheduledActionDrawAndSwap", "forced", forced_draw);
 
   ScheduledActionDrawAndSwapResult result;
   result.did_draw = false;
   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());
@@ skipping 140 matching lines @@
   CompletionEvent completion;
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::AcquireLayerTexturesForMainThreadOnImplThread,
                  impl_thread_weak_ptr_,
                  &completion));
   // Block until it is safe to write to layer textures from the main thread.
   completion.Wait();
 
   textures_acquired_ = true;
+  can_cancel_commit_ = false;
 }
 
 void ThreadProxy::AcquireLayerTexturesForMainThreadOnImplThread(
     CompletionEvent* completion) {
   DCHECK(IsImplThread());
   DCHECK(!texture_acquisition_completion_event_on_impl_thread_);
 
   texture_acquisition_completion_event_on_impl_thread_ = completion;
   scheduler_on_impl_thread_->SetMainThreadNeedsLayerTextures();
 }
@@ skipping 356 matching lines @@
     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;
   }
 
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 }  // namespace cc