cc: Allow the main thread to cancel commits

cc/trees/layer_tree_host.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/layer_tree_host.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 447 matching lines @@
 
 const RendererCapabilities& LayerTreeHost::GetRendererCapabilities() const {
   return proxy_->GetRendererCapabilities();
 }
 
 void LayerTreeHost::SetNeedsAnimate() {
   DCHECK(proxy_->HasImplThread());
   proxy_->SetNeedsAnimate();
 }
 
+void LayerTreeHost::SetNeedsUpdateLayers() {
+  proxy_->SetNeedsUpdateLayers();
+}
+
 void LayerTreeHost::SetNeedsCommit() {
   if (!prepaint_callback_.IsCancelled()) {
     TRACE_EVENT_INSTANT0("cc",
                          "LayerTreeHost::SetNeedsCommit::cancel prepaint",
                          TRACE_EVENT_SCOPE_THREAD);
     prepaint_callback_.Cancel();
   }
   proxy_->SetNeedsCommit();
 }
 
@@ skipping 95 matching lines @@
   if (overdraw_bottom_height_ == overdraw_bottom_height)
     return;
 
   overdraw_bottom_height_ = overdraw_bottom_height;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
-  if (page_scale_factor == page_scale_factor_ &&
+  bool same_page_scale_factor = page_scale_factor == page_scale_factor_;
+  bool same_page_scale_limits =
       min_page_scale_factor == min_page_scale_factor_ &&
-      max_page_scale_factor == max_page_scale_factor_)
+      max_page_scale_factor == max_page_scale_factor_;
+  if (same_page_scale_factor && same_page_scale_limits)
     return;
 
   page_scale_factor_ = page_scale_factor;
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
-  SetNeedsCommit();
+
+  if (same_page_scale_limits)

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

So I guess the main thread is not able to set the PSF any more?

Maybe we should split this function up and name things more clearly to express
that? Like SetPageScaleFactorFromImplThread() similar to the scroll offset
stuff?

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

Done.

+    SetNeedsUpdateLayers();
+  else
+    SetNeedsCommit();
 }
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   if (!visible)
     ReduceMemoryUsage();
   proxy_->SetVisible(visible);
 }
@@ skipping 339 matching lines @@
 
   in_paint_layer_contents_ = false;
 
   occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
 }
 
 void LayerTreeHost::ApplyScrollAndScale(const ScrollAndScaleSet& info) {
   if (!root_layer_.get())
     return;
 
+  gfx::Vector2d root_scroll_delta;
   Layer* root_scroll_layer = FindFirstScrollableLayer(root_layer_.get());
-  gfx::Vector2d root_scroll_delta;
 
   for (size_t i = 0; i < info.scrolls.size(); ++i) {
     Layer* layer =
         LayerTreeHostCommon::FindLayerInSubtree(root_layer_.get(),
                                                 info.scrolls[i].layer_id);
     if (!layer)
       continue;
     if (layer == root_scroll_layer) {
       root_scroll_delta += info.scrolls[i].scroll_delta;
     } else {
       layer->SetScrollOffsetFromImplSide(layer->scroll_offset() +
                                          info.scrolls[i].scroll_delta);
     }
   }
-  if (!root_scroll_delta.IsZero() || info.page_scale_delta != 1.f)
+
+  if (!root_scroll_delta.IsZero() || info.page_scale_delta != 1.f) {
+    // SetScrollOffsetFromImplSide above could have destroyed the tree,
+    // so re-get this layer before doing anything to it.
+    root_scroll_layer = FindFirstScrollableLayer(root_layer_.get());
+
+    // Preemptively apply the scroll offset here before sending it to
+    // the client.  If the client comes back and sets it to the same value,
+    // then the layer can early out without needing a full commit.
+    if (root_scroll_layer) {
+      root_scroll_layer->SetScrollOffsetFromImplSide(
+          root_scroll_layer->scroll_offset() + root_scroll_delta);
+    }
     client_->ApplyScrollAndScale(root_scroll_delta, info.page_scale_delta);
+  }
 }
 
 void LayerTreeHost::StartRateLimiter(WebKit::WebGraphicsContext3D* context3d) {
   if (animating_)
     return;
 
   DCHECK(context3d);
   RateLimiterMap::iterator it = rate_limiters_.find(context3d);
   if (it != rate_limiters_.end()) {
     it->second->Start();
@@ skipping 83 matching lines @@
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc