Pinch/Zoom Infrastructure & Plumbing CL

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 369 matching lines @@
                                 &memory_used_bytes);
   SendManagedMemoryStats(memory_required_bytes,
                          memory_nice_to_have_bytes,
                          memory_used_bytes);
 }
 
 void LayerTreeHostImpl::StartPageScaleAnimation(gfx::Vector2d target_offset,
                                                 bool anchor_point,
                                                 float page_scale,
                                                 base::TimeDelta duration) {
-  if (!RootScrollLayer())
+  if (!InnerViewportScrollLayer())
     return;
 
+  // Should we attempt to set to OuterViewportScrollingLayer if it's available?
+  active_tree_->SetCurrentlyScrollingLayer(InnerViewportScrollLayer());
+
   gfx::Vector2dF scroll_total =
-      RootScrollLayer()->scroll_offset() + RootScrollLayer()->ScrollDelta();
+      active_tree_->TotalScrollOffset() + active_tree_->TotalScrollDelta();
   gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
   gfx::SizeF viewport_size = UnscaledScrollableViewportSize();
 
   // Easing constants experimentally determined.
   scoped_ptr<TimingFunction> timing_function =
       CubicBezierTimingFunction::Create(.8, 0, .3, .9).PassAs<TimingFunction>();
 
   page_scale_animation_ =
       PageScaleAnimation::Create(scroll_total,
                                  active_tree_->total_page_scale_factor(),
@@ skipping 832 matching lines @@
   metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
   metadata.latency_info = active_tree_->GetLatencyInfo();
   if (top_controls_manager_) {
     metadata.location_bar_offset =
         gfx::Vector2dF(0.f, top_controls_manager_->controls_top_offset());
     metadata.location_bar_content_translation =
         gfx::Vector2dF(0.f, top_controls_manager_->content_top_offset());
     metadata.overdraw_bottom_height = overdraw_bottom_height_;
   }
 
-  if (!RootScrollLayer())
+  if (!InnerViewportScrollLayer())
     return metadata;
 
-  metadata.root_scroll_offset = RootScrollLayer()->TotalScrollOffset();
+  metadata.root_scroll_offset = active_tree_->TotalScrollOffset();
 
   return metadata;
 }
 
 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
   layer->DidBeginTracing();
 }
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
@@ skipping 167 matching lines @@
     client_->DidLoseOutputSurfaceOnImplThread();
 }
 
 void LayerTreeHostImpl::Readback(void* pixels,
                                  gfx::Rect rect_in_device_viewport) {
   DCHECK(renderer_);
   renderer_->GetFramebufferPixels(pixels, rect_in_device_viewport);
 }
 
 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
-  return !!RootScrollLayer();
+  return !!InnerViewportScrollLayer();
 }
 
 LayerImpl* LayerTreeHostImpl::RootLayer() const {
   return active_tree_->root_layer();
 }
 
-LayerImpl* LayerTreeHostImpl::RootScrollLayer() const {
-  return active_tree_->RootScrollLayer();
+LayerImpl* LayerTreeHostImpl::InnerViewportScrollLayer() const {
+  return active_tree_->InnerViewportScrollLayer();
+}
+
+LayerImpl* LayerTreeHostImpl::OuterViewportScrollLayer() const {
+  return active_tree_->OuterViewportScrollLayer();
 }
 
 LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
   return active_tree_->CurrentlyScrollingLayer();
 }
 
 bool LayerTreeHostImpl::IsCurrentlyScrolling() const {
   return CurrentlyScrollingLayer() ||
-         (RootScrollLayer() && RootScrollLayer()->IsExternalFlingActive());
+         (InnerViewportScrollLayer() &&
+          InnerViewportScrollLayer()->IsExternalFlingActive()) ||
+         (OuterViewportScrollLayer() &&
+          OuterViewportScrollLayer()->IsExternalFlingActive());
 }
 
 // Content layers can be either directly scrollable or contained in an outer
 // scrolling layer which applies the scroll transform. Given a content layer,
 // this function returns the associated scroll layer if any.
 static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
   if (!layer_impl)
     return NULL;
 
   if (layer_impl->scrollable())
@@ skipping 353 matching lines @@
 
 void LayerTreeHostImpl::SetViewportSize(gfx::Size device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   if (pending_tree_)
     active_tree_->SetViewportSizeInvalid();
 
   device_viewport_size_ = device_viewport_size;
 
-  UpdateMaxScrollOffset();
-
   if (renderer_)
     renderer_->ViewportChanged();
 
   client_->OnCanDrawStateChanged(CanDraw());
   SetFullRootLayerDamage();
 }
 
 void LayerTreeHostImpl::SetOverdrawBottomHeight(float overdraw_bottom_height) {
   if (overdraw_bottom_height == overdraw_bottom_height_)
     return;
   overdraw_bottom_height_ = overdraw_bottom_height;
 
-  UpdateMaxScrollOffset();
   SetFullRootLayerDamage();
 }
 
 void LayerTreeHostImpl::SetOverhangUIResource(
     UIResourceId overhang_ui_resource_id,
     gfx::Size overhang_ui_resource_size) {
   overhang_ui_resource_id_ = overhang_ui_resource_id;
   overhang_ui_resource_size_ = overhang_ui_resource_size;
 }
 
 void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
   if (renderer_)
     renderer_->ViewportChanged();
 
-  UpdateMaxScrollOffset();
   SetFullRootLayerDamage();
 }
 
 gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
   return DeviceViewport().size();
 }
 
 gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
   if (external_viewport_.IsEmpty())
     return gfx::Rect(device_viewport_size_);
 
   return external_viewport_;
 }
 
 gfx::Rect LayerTreeHostImpl::DeviceClip() const {
   if (external_clip_.IsEmpty())
     return DeviceViewport();
 
   return external_clip_;
 }
 
 const gfx::Transform& LayerTreeHostImpl::DrawTransform() const {
   return external_transform_;
 }
 
-void LayerTreeHostImpl::UpdateMaxScrollOffset() {
-  active_tree_->UpdateMaxScrollOffset();
-}
-
 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
   client_->SetNeedsRedrawOnImplThread();
   active_tree_->set_needs_update_draw_properties();
   SetFullRootLayerDamage();
 }
 
 bool LayerTreeHostImpl::EnsureRenderSurfaceLayerList() {
   active_tree_->UpdateDrawProperties();
   return !active_tree_->RenderSurfaceLayerList().empty();
 }
@@ skipping 39 matching lines @@
     if (status == ScrollStarted && !potentially_scrolling_layer_impl)
       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
   // When hiding top controls is enabled and the controls are hidden or
   // overlaying the content, force scrolls to be enabled on the root layer to
   // allow bringing the top controls back into view.
   if (!potentially_scrolling_layer_impl && top_controls_manager_ &&
       top_controls_manager_->content_top_offset() !=
       settings_.top_controls_height) {
-    potentially_scrolling_layer_impl = RootScrollLayer();
+    potentially_scrolling_layer_impl =
+        OuterViewportScrollLayer() ? OuterViewportScrollLayer()
+                                   : InnerViewportScrollLayer();
   }
 
   return potentially_scrolling_layer_impl;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     gfx::Point viewport_point, InputHandler::ScrollInputType type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
 
   if (top_controls_manager_)
@@ skipping 15 matching lines @@
       FindScrollLayerForDeviceViewportPoint(device_viewport_point, type,
           layer_impl, &scroll_on_main_thread);
 
   if (scroll_on_main_thread) {
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
     return ScrollOnMainThread;
   }
 
   // If we want to send a DidOverscroll for this scroll it can't be ignored.
   if (!potentially_scrolling_layer_impl && settings_.always_overscroll)
-    potentially_scrolling_layer_impl = RootScrollLayer();
+    potentially_scrolling_layer_impl =
+        OuterViewportScrollLayer() ? OuterViewportScrollLayer()
+                                   : InnerViewportScrollLayer();
 
   if (potentially_scrolling_layer_impl) {
     active_tree_->SetCurrentlyScrollingLayer(
         potentially_scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     last_scroll_did_bubble_ = false;
     wheel_scrolling_ = (type == Wheel);
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
@@ skipping 88 matching lines @@
                                  gfx::Vector2dF scroll_delta) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
   if (!CurrentlyScrollingLayer())
     return false;
 
   gfx::Vector2dF pending_delta = scroll_delta;
   gfx::Vector2dF unused_root_delta;
   bool did_scroll_x = false;
   bool did_scroll_y = false;
   bool consume_by_top_controls = top_controls_manager_ &&
-      (CurrentlyScrollingLayer() == RootScrollLayer() || scroll_delta.y() < 0);
+      (CurrentlyScrollingLayer() == InnerViewportScrollLayer() || scroll_delta.y() < 0);
   last_scroll_did_bubble_ = false;
 
   for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
        layer_impl;
        layer_impl = layer_impl->parent()) {
     if (!layer_impl->scrollable())
       continue;
 
-    if (layer_impl == RootScrollLayer()) {
+    if (layer_impl == InnerViewportScrollLayer()) {
       // Only allow bubble scrolling when the scroll is in the direction to make
       // the top controls visible.
-      if (consume_by_top_controls && layer_impl == RootScrollLayer()) {
+      if (consume_by_top_controls && layer_impl == InnerViewportScrollLayer())
         pending_delta = top_controls_manager_->ScrollBy(pending_delta);
-        UpdateMaxScrollOffset();
-      }
       // Track root layer deltas for reporting overscroll.
       unused_root_delta = pending_delta;
     }
 
     gfx::Vector2dF applied_delta;
     // Gesture events need to be transformed from viewport coordinates to local
     // layer coordinates so that the scrolling contents exactly follow the
     // user's finger. In contrast, wheel events represent a fixed amount of
     // scrolling so we can just apply them directly.
     if (!wheel_scrolling_) {
@@ skipping 17 matching lines @@
         continue;
 
       if (should_bubble_scrolls_) {
         last_scroll_did_bubble_ = true;
         continue;
       }
 
       break;
     }
 
-    if (layer_impl == RootScrollLayer())
+    if (layer_impl == InnerViewportScrollLayer() ||
+        layer_impl == OuterViewportScrollLayer())
       unused_root_delta.Subtract(applied_delta);
 
     did_lock_scrolling_layer_ = true;
     if (!should_bubble_scrolls_) {
       active_tree_->SetCurrentlyScrollingLayer(layer_impl);
       break;
     }
 
     // If the applied delta is within 45 degrees of the input delta, bail out to
     // make it easier to scroll just one layer in one direction without
@@ skipping 46 matching lines @@
 bool LayerTreeHostImpl::ScrollVerticallyByPage(gfx::Point viewport_point,
                                                ScrollDirection direction) {
   DCHECK(wheel_scrolling_);
 
   for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
        layer_impl;
        layer_impl = layer_impl->parent()) {
     if (!layer_impl->scrollable())
       continue;
 
-    if (!layer_impl->vertical_scrollbar_layer())
+    if (!layer_impl->HasScrollbar(VERTICAL))
       continue;
 
-    float height = layer_impl->vertical_scrollbar_layer()->bounds().height();
+   // TODO(wjmaclean) make sure this is ok!
+    float height = layer_impl->clip_height();
 
     // These magical values match WebKit and are designed to scroll nearly the
     // entire visible content height but leave a bit of overlap.
     float page = std::max(height * 0.875f, 1.f);
     if (direction == SCROLL_BACKWARD)
       page = -page;
 
     gfx::Vector2dF delta = gfx::Vector2dF(0.f, page);
 
     gfx::Vector2dF applied_delta = ScrollLayerWithLocalDelta(layer_impl, delta);
@@ skipping 35 matching lines @@
     top_controls_manager_->ScrollEnd();
   ClearCurrentlyScrollingLayer();
   StartScrollbarAnimation();
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   if (!active_tree_->CurrentlyScrollingLayer())
     return ScrollIgnored;
 
   if (settings_.ignore_root_layer_flings &&
-      active_tree_->CurrentlyScrollingLayer() ==
-          active_tree_->RootScrollLayer()) {
+      (active_tree_->CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
+       active_tree_->CurrentlyScrollingLayer() == OuterViewportScrollLayer())) {
     ClearCurrentlyScrollingLayer();
     return ScrollIgnored;
   }
 
   if (!wheel_scrolling_)
     should_bubble_scrolls_ = last_scroll_did_bubble_;
 
   return ScrollStarted;
 }
 
@@ skipping 39 matching lines @@
         scroll_layer_impl->scrollbar_animation_controller();
     if (animation_controller) {
       animation_controller->DidMouseMoveOffScrollbar(
           CurrentPhysicalTimeTicks());
       StartScrollbarAnimation();
     }
     scroll_layer_id_when_mouse_over_scrollbar_ = 0;
   }
 
   bool scroll_on_main_thread = false;
+  // wjm - what does FindScrollLayerForDeviceViewportPoint exactly do?
   LayerImpl* scroll_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, InputHandler::Gesture, layer_impl,
       &scroll_on_main_thread);
   if (scroll_on_main_thread || !scroll_layer_impl)
     return;
 
   ScrollbarAnimationController* animation_controller =
       scroll_layer_impl->scrollbar_animation_controller();
   if (!animation_controller)
     return;
 
-  float distance_to_scrollbar = std::min(
-      DeviceSpaceDistanceToLayer(device_viewport_point,
-          scroll_layer_impl->horizontal_scrollbar_layer()),
-      DeviceSpaceDistanceToLayer(device_viewport_point,
-          scroll_layer_impl->vertical_scrollbar_layer()));
+  // TODO(wjmaclean) What to do with this? is it ok to choose from more than
+  // two scrollbars?
+  float distance_to_scrollbar = std::numeric_limits<float>::max();
+  for (LayerImpl::ScrollbarSet::iterator it =
+           scroll_layer_impl->scrollbars()->begin();
+       it != scroll_layer_impl->scrollbars()->end();
+       ++it)
+    distance_to_scrollbar = std::min(distance_to_scrollbar,
+        DeviceSpaceDistanceToLayer(device_viewport_point, *it));
 
   bool should_animate = animation_controller->DidMouseMoveNear(
       CurrentPhysicalTimeTicks(), distance_to_scrollbar / device_scale_factor_);
   if (should_animate) {
     client_->SetNeedsRedrawOnImplThread();
     StartScrollbarAnimation();
   }
 }
 
 bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
@@ skipping 13 matching lines @@
   }
 
   return false;
 }
 
 void LayerTreeHostImpl::PinchGestureBegin() {
   pinch_gesture_active_ = true;
   previous_pinch_anchor_ = gfx::Point();
   client_->RenewTreePriority();
   pinch_gesture_end_should_clear_scrolling_layer_ = !CurrentlyScrollingLayer();
-  active_tree_->SetCurrentlyScrollingLayer(RootScrollLayer());
+  if (active_tree_->OuterViewportScrollLayer()) {
+    active_tree_->SetCurrentlyScrollingLayer(
+        active_tree_->OuterViewportScrollLayer());
+  } else {
+    active_tree_->SetCurrentlyScrollingLayer(
+        active_tree_->InnerViewportScrollLayer());
+  }
 }
 
 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
                                            gfx::Point anchor) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
 
-  if (!RootScrollLayer())
+  LayerImpl* pinch_scroll_layer = CurrentlyScrollingLayer();
+  if (!pinch_scroll_layer)
+    pinch_scroll_layer = InnerViewportScrollLayer();
+
+  if (!pinch_scroll_layer)
     return;
 
   // Keep the center-of-pinch anchor specified by (x, y) in a stable
   // position over the course of the magnify.
   float page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF previous_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
   active_tree_->SetPageScaleDelta(page_scale_delta * magnify_delta);
   page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF new_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
   gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
 
   previous_pinch_anchor_ = anchor;
 
   move.Scale(1 / active_tree_->page_scale_factor());
+  // When shrinking the page, the current scroll offset of the inner viewport
+  // scroll layer may need to be adjusted so that it doesn't exceed its maximum
+  // at the new page scale factor.
+  if (magnify_delta < 1.f) {
+    // If clamping the inner viewport scroll offset causes a change, it should
+    // be accounted for from the intended move.
+    move -= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
+  }
 
-  RootScrollLayer()->ScrollBy(move);
+  // We manually manage the bubbling behaviour here as it is different to that
+  // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
+  // 1) we want to explicit limit the bubbling to the outer/inner viewports,
+  // 2) we don't want the directional limitations on the unused parts that
+  //    ScrollBy() implements, and
+  // 3) pinching should not engage the top controls manager.
+  gfx::Vector2dF unused = pinch_scroll_layer->ScrollBy(move);
 
+  if (!unused.IsZero() && pinch_scroll_layer == OuterViewportScrollLayer()) {
+    InnerViewportScrollLayer()->ScrollBy(unused);
+    InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
+    active_tree_->SetCurrentlyScrollingLayer(
+        active_tree_->InnerViewportScrollLayer());
+  }
+/*
+  // Don't enable during unit tests.
+  {
+    gfx::Vector2d maxi = InnerViewportScrollLayer()->MaxScrollOffset();
+    gfx::Vector2d maxo = OuterViewportScrollLayer()->MaxScrollOffset();
+    gfx::Vector2dF offi = InnerViewportScrollLayer()->TotalScrollOffset();
+    gfx::Vector2dF offo = OuterViewportScrollLayer()->TotalScrollOffset();
+  fprintf(stderr, "wjm: Viewport summary: ovsl = (%f,%f) of (%d,%d), ivsl = (%f,%f) of (%d,%d)\n",
+      offo.x(), offo.y(),
+      maxo.x(), maxo.y(),
+      offi.x(), offi.y(),
+      maxi.x(), maxi.y());
+  }
+*/
   client_->SetNeedsCommitOnImplThread();
   client_->SetNeedsRedrawOnImplThread();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::PinchGestureEnd() {
   pinch_gesture_active_ = false;
   if (pinch_gesture_end_should_clear_scrolling_layer_) {
     pinch_gesture_end_should_clear_scrolling_layer_ = false;
     ClearCurrentlyScrollingLayer();
@@ skipping 28 matching lines @@
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
 void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {
-  if (!page_scale_animation_ || !RootScrollLayer())
+  if (!page_scale_animation_)
     return;
 
   double monotonic_time = (time - base::TimeTicks()).InSecondsF();
-  gfx::Vector2dF scroll_total = RootScrollLayer()->scroll_offset() +
-                                RootScrollLayer()->ScrollDelta();
+  gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
 
   if (!page_scale_animation_->IsAnimationStarted())
     page_scale_animation_->StartAnimation(monotonic_time);
 
   active_tree_->SetPageScaleDelta(
       page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
       active_tree_->page_scale_factor());
   gfx::Vector2dF next_scroll =
       page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
 
-  RootScrollLayer()->ScrollBy(next_scroll - scroll_total);
+  ScrollBy(gfx::Point(), next_scroll - scroll_total);
   client_->SetNeedsRedrawOnImplThread();
 
   if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
     page_scale_animation_.reset();
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
   }
 }
 
 void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
-  if (!top_controls_manager_ || !RootScrollLayer())
+  if (!top_controls_manager_)
     return;
   gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
-  UpdateMaxScrollOffset();
-  if (RootScrollLayer()->TotalScrollOffset().y() == 0.f)
+  if (active_tree_->TotalScrollOffset().y() == 0.f)
     return;
-  RootScrollLayer()->ScrollBy(gfx::ScaleVector2d(
-      scroll, 1.f / active_tree_->total_page_scale_factor()));
+  ScrollBy(gfx::Point(),
+           gfx::ScaleVector2d(scroll,
+                              1.f / active_tree_->total_page_scale_factor()));
 }
 
 void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time,
                                       base::Time wall_clock_time) {
   if (!settings_.accelerated_animation_enabled ||
       animation_registrar_->active_animation_controllers().empty() ||
       !active_tree_->root_layer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
@@ skipping 311 matching lines @@
   std::set<UIResourceId>::iterator found_in_evicted =
       evicted_ui_resources_.find(uid);
   if (found_in_evicted == evicted_ui_resources_.end())
     return;
   evicted_ui_resources_.erase(found_in_evicted);
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 }  // namespace cc