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 71 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_(false),
       defer_commits_(false),
       renew_tree_priority_on_impl_thread_pending_(false),
       draw_duration_history_(kDrawDurationHistorySize) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_);
 }
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
@@ skipping 16 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() {

[brianderson, 2013/07/13 01:26:42]

While you are adding this method, it looks like commit_requested and
commit_request_sent_to_imple_thread_ are redundant. Do you mind removing one?

[enne (OOO), 2013/07/15 22:23:28]

It doesn't look like one can be removed.  commit_requested_ (unlike
commit_request_sent_to_impl_thread_) is also used for
ThreadProxy::CommitRequested and indirectly for LayerTreeHost::CommitRequested.

See https://bugs.webkit.org/show_bug.cgi?id=95393 for why this was introduced in
the first place.

+  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());
+  // This needs to unconditionally be set here, because the during

[brianderson, 2013/07/13 01:26:42]

Nit: -the

[enne (OOO), 2013/07/15 22:23:28]

Done.

+  // begin frame commit_requested_ is set unconditionally to true
+  // to suppress extra commits, however we don't want to suppress cancels.

[brianderson, 2013/07/13 01:26:42]

Triple negative made that last part of the comment hard to parse. How about:
", however we still want to be able to prevent cancels."

[enne (OOO), 2013/07/15 22:23:28]

Cleaned up this comment in general.

+  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 329 matching lines @@
   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 cancel_commit = false;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
-                   impl_thread_weak_ptr_));
+                   impl_thread_weak_ptr_,
+                   cancel_commit));
     return;
   }
 
   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);
+
+  if (!updated && can_cancel_this_commit) {

[brianderson, 2013/07/13 01:26:42]

If "updated" is false, what else is there to commit after a readback,
SetNeedsAnimate, and SetNeedsCommit? Are there any more cases where we can
cancel the commit?

[enne (OOO), 2013/07/15 22:23:28]

The low-hanging fruit here are the cases I've added in this patch (unhandled
invalidations, page scale, scrolling on the compositor thread).

Follow-up to this patch could be being smarter with SetNeedsAnimate or not
setting SetNeedsCommit when a layer !DrawsContent().

+    TRACE_EVENT0("cc", "EarlyOut_NoUpdates");
+    bool cancel_commit = true;
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
+                   impl_thread_weak_ptr_,
+                   cancel_commit));
+    return;
+  }
 
   // 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
@@ skipping 86 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 cancel_commit) {
   TRACE_EVENT0("cc", "ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(scheduler_on_impl_thread_);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
 
-  scheduler_on_impl_thread_->BeginFrameAbortedByMainThread();
+  // The 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.
+  layer_tree_host_impl_->active_tree()->ApplySentScrollAndScaleDeltas();
+  scheduler_on_impl_thread_->BeginFrameAbortedByMainThread(cancel_commit);
 }
 
 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 592 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