cc: Allow the main thread to cancel commits

cc/trees/single_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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_update_controller.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 
 scoped_ptr<Proxy> SingleThreadProxy::Create(LayerTreeHost* layer_tree_host) {
   return make_scoped_ptr(
       new SingleThreadProxy(layer_tree_host)).PassAs<Proxy>();
 }
 
 SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host)
     : Proxy(NULL),
       layer_tree_host_(layer_tree_host),
       created_offscreen_context_provider_(false),
       next_frame_is_newly_committed_frame_(false),
-      inside_draw_(false) {
+      inside_draw_(false),
+      can_cancel_commit_(false) {

[danakj, 2013/07/17 20:53:24]

Init this to true? (We start without a SNC scheduled)

[enne (OOO), 2013/07/18 17:36:37]

Done.

   TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
   DCHECK(Proxy::IsMainThread());
   DCHECK(layer_tree_host);
 
   // Impl-side painting not supported without threaded compositing.
   CHECK(!layer_tree_host->settings().impl_side_painting)
       << "Threaded compositing must be enabled to use impl-side painting.";
 }
 
 void SingleThreadProxy::Start(scoped_ptr<OutputSurface> first_output_surface) {
@@ skipping 124 matching lines @@
   DCHECK(Proxy::IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_for_main_thread_;
 }
 
 void SingleThreadProxy::SetNeedsAnimate() {
   // Thread-only feature.
   NOTREACHED();
 }
 
+void SingleThreadProxy::SetNeedsUpdateLayers() {
+  DCHECK(Proxy::IsMainThread());
+  layer_tree_host_->ScheduleComposite();
+}
+
 void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
   DCHECK(Proxy::IsMainThread());
   // Commit immediately.
   {
     DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     DebugScopedSetImplThread impl(this);
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host_->rendering_stats_instrumentation();
     base::TimeTicks start_time = stats_instrumentation->StartRecording();
@@ skipping 12 matching lines @@
             Proxy::MainThreadTaskRunner(),
             queue.Pass(),
             layer_tree_host_impl_->resource_provider());
     update_controller->Finalize();
 
     layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
 
     layer_tree_host_impl_->CommitComplete();
 
 #ifndef NDEBUG
     // In the single-threaded case, the scroll deltas should never be

[danakj, 2013/07/17 20:53:24]

nit: scale and scroll deltas

[enne (OOO), 2013/07/18 17:36:37]

Done.

     // touched on the impl layer tree.
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         layer_tree_host_impl_->ProcessScrollDeltas();
     DCHECK(!scroll_info->scrolls.size());
+    DCHECK_EQ(1.f, scroll_info->page_scale_delta);
 #endif
 
     base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
     stats_instrumentation->AddCommit(duration);
   }
   layer_tree_host_->CommitComplete();
   next_frame_is_newly_committed_frame_ = true;
 }
 
 void SingleThreadProxy::SetNeedsCommit() {
   DCHECK(Proxy::IsMainThread());
+  can_cancel_commit_ = false;
   layer_tree_host_->ScheduleComposite();
 }
 
 void SingleThreadProxy::SetNeedsRedraw(gfx::Rect damage_rect) {
   SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void SingleThreadProxy::OnHasPendingTreeStateChanged(bool have_pending_tree) {
   // Thread-only feature.
   NOTREACHED();
@@ skipping 23 matching lines @@
   }
   layer_tree_host_ = NULL;
 }
 
 void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   DCHECK(Proxy::IsImplThread());
   layer_tree_host_impl_->UpdateBackgroundAnimateTicking(!ShouldComposite());
 }
 
 void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
+  // Since commit+draw happens in a single pass for this proxy,
+  // this also prevents cancelling a commit.
+  can_cancel_commit_ = false;
   layer_tree_host_->ScheduleComposite();
 }
 
 void SingleThreadProxy::SetNeedsRedrawRectOnImplThread(gfx::Rect damage_rect) {
   // TODO(brianderson): Once we move render_widget scheduling into this class,
   // we can treat redraw requests more efficiently than CommitAndRedraw
   // requests.
   layer_tree_host_impl_->SetViewportDamage(damage_rect);
   SetNeedsCommit();
 }
@@ skipping 118 matching lines @@
         layer_tree_host_->client()->OffscreenContextProviderForMainThread();
     if (offscreen_context_provider.get())
       created_offscreen_context_provider_ = true;
   }
 
   if (layer_tree_host_->contents_texture_manager()) {
     layer_tree_host_->contents_texture_manager()
         ->UnlinkAndClearEvictedBackings();
   }
 
+  // Reset this flag for the next commit.  It's possible that UpdateLayers
+  // will force another commit, so record this flag.
+  bool can_cancel_this_commit = can_cancel_commit_ && !for_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(), layer_tree_host_impl_->memory_allocation_limit_bytes());
 
   layer_tree_host_->WillCommit();
+
+  if (!updated && can_cancel_this_commit) {
+    TRACE_EVENT0("cc", "EarlyOut_NoUpdates");

[danakj, 2013/07/17 20:53:24]

nit: SingleThreadProxy::CommitAndComposite::EarlyOut_NoUpdates? (I don't see a
nearby nested trace event that would make this scope obvious)

[enne (OOO), 2013/07/18 17:36:37]

Removed with the rest of the changes to single thread proxy.

+    // From the perspective of the embedder, this commit still occurred.
+    layer_tree_host_->CommitComplete();
+    layer_tree_host_->DidBeginFrame();
+    return false;
+  }
+
   DoCommit(queue.Pass());
   bool result = DoComposite(offscreen_context_provider,
                             frame_begin_time,
                             device_viewport_damage_rect,
                             for_readback,
                             frame);
   layer_tree_host_->DidBeginFrame();
+
   return result;
 }
 
 bool SingleThreadProxy::ShouldComposite() const {
   DCHECK(Proxy::IsImplThread());
   return layer_tree_host_impl_->visible() &&
          layer_tree_host_impl_->CanDraw();
 }
 
 bool SingleThreadProxy::DoComposite(
@@ skipping 60 matching lines @@
 
 bool SingleThreadProxy::CommitPendingForTesting() { return false; }
 
 skia::RefPtr<SkPicture> SingleThreadProxy::CapturePicture() {
   // Impl-side painting only.
   NOTREACHED();
   return skia::RefPtr<SkPicture>();
 }
 
 }  // namespace cc