Pinch/Zoom Infrastructure & Plumbing CL

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 <string>
 
@@ skipping 331 matching lines @@
     LayerImpl* hud_impl = LayerTreeHostCommon::FindLayerInSubtree(
         sync_tree->root_layer(), hud_layer_->id());
     sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
   } else {
     sync_tree->set_hud_layer(NULL);
   }
 
   sync_tree->set_background_color(background_color_);
   sync_tree->set_has_transparent_background(has_transparent_background_);
 
-  sync_tree->FindRootScrollLayer();
-
-  // TODO(wjmaclean) For now, not all LTH clients will register viewports, so
-  // only set them when available..
-  if (page_scale_layer_) {
-    DCHECK(inner_viewport_scroll_layer_);
+  if (page_scale_layer_ && inner_viewport_scroll_layer_) {
     sync_tree->SetViewportLayersFromIds(
         page_scale_layer_->id(),
         inner_viewport_scroll_layer_->id(),
         outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id()
                                      : Layer::INVALID_ID);
   } else {
     sync_tree->ClearViewportLayers();
   }
 
   float page_scale_delta, sent_page_scale_delta;
@@ skipping 683 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 inner_viewport_scroll_delta;
+  gfx::Vector2d outer_viewport_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;
+    if (layer == outer_viewport_scroll_layer_.get()) {
+      outer_viewport_scroll_delta += info.scrolls[i].scroll_delta;
+    } else if (layer == inner_viewport_scroll_layer_.get()) {
+      inner_viewport_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 (!inner_viewport_scroll_delta.IsZero() ||
+      !outer_viewport_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 and scale delta 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);
+    DCHECK(inner_viewport_scroll_layer_);  // We should always have this.
+
+    inner_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
+        inner_viewport_scroll_layer_->scroll_offset() +
+        inner_viewport_scroll_delta);
+    if (outer_viewport_scroll_layer_) {
+      outer_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
+          outer_viewport_scroll_layer_->scroll_offset() +
+          outer_viewport_scroll_delta);
     }
     ApplyPageScaleDeltaFromImplSide(info.page_scale_delta);
-    client_->ApplyScrollAndScale(root_scroll_delta, info.page_scale_delta);
+
+    client_->ApplyScrollAndScale(
+        inner_viewport_scroll_delta + outer_viewport_scroll_delta,
+        info.page_scale_delta);
   }
 }
 
+gfx::Vector2d LayerTreeHost::DistributeScrollOffsetToViewports(
+    const gfx::Vector2d offset,
+    Layer* layer) {
+  DCHECK(layer);
+  if (layer != outer_viewport_scroll_layer_.get())
+    return offset;
+
+  // If we get to this point, we are assured we have an outer viewport.

[enne (OOO), 2013/11/14 22:59:01]

No comment, just DCHECK.

[wjmaclean, 2013/12/24 21:03:49]

Done.

+  gfx::Vector2d inner_viewport_offset =
+      inner_viewport_scroll_layer_->scroll_offset();
+  gfx::Vector2d outer_viewport_offset =
+      outer_viewport_scroll_layer_->scroll_offset();
+
+  if (offset == inner_viewport_offset + outer_viewport_offset) {
+    // In this case, nothing should change, so we just return to the outer
+    // viewport the offset is already has.
+    return outer_viewport_offset;
+  }
+
+  // In the spirit of document-scrolls-first, we always want any change to
+  // go to the outer viewport first.
+  gfx::Vector2d max_outer_viewport_scroll_offset =
+      outer_viewport_scroll_layer_->MaxScrollOffset();
+#ifndef NDEBUG
+// The DCHECK below is triggering during zoom-out.

[enne (OOO), 2013/11/14 22:59:01]

This seems like a good thing to track down.  How far off is this when it's
wrong? Is this an off-by-one/rounding error?

[wjmaclean, 2013/12/24 21:03:49]

This seems to be an off-by-one (or two) type of error. I'm working on tracking
it down ... since it only presents itself when the flag is turned on, can we
file a bug for it, and fix it separately from this patch (assuming I don't find
a fix before this CL lands?)

[enne (OOO), 2014/01/02 19:28:17]

Ok.  This seems pretty serious, but endless rebaselining can't be fun from your
end.  It seems much better to spend your time getting this landed sooner rather
than later and fix it up after.

+/*
+  gfx::Vector2d maxInnerViewportScrollOffset =
+      inner_viewport_scroll_layer_->MaxScrollOffset();
+
+  gfx::Vector2d totalMaxScrollOffset =
+      max_outer_viewport_scroll_offset + maxInnerViewportScrollOffset;
+  DCHECK(totalMaxScrollOffset.x() >= offset.x() &&
+         totalMaxScrollOffset.y() >= offset.y());
+*/
+#endif
+
+  outer_viewport_offset = offset - inner_viewport_offset;
+  outer_viewport_offset.SetToMin(max_outer_viewport_scroll_offset);
+  outer_viewport_offset.SetToMax(gfx::Vector2d());
+
+  inner_viewport_offset = offset - outer_viewport_offset;
+  inner_viewport_scroll_layer_->SetScrollOffset(inner_viewport_offset);
+
+  return outer_viewport_offset;
+}
+
 void LayerTreeHost::StartRateLimiter() {
   if (animating_)
     return;
 
   if (!rate_limit_timer_.IsRunning()) {
     rate_limit_timer_.Start(FROM_HERE,
                             base::TimeDelta(),
                             this,
                             &LayerTreeHost::RateLimit);
   }
@@ skipping 153 matching lines @@
 
 bool LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     scoped_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
   return micro_benchmark_controller_.ScheduleRun(
       benchmark_name, value.Pass(), callback);
 }
 
 }  // namespace cc