Pinch/Zoom Infrastructure & Plumbing CL

cc/layers/layer_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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
@@ skipping 21 matching lines @@
     : parent_(NULL),
       scroll_parent_(NULL),
       clip_parent_(NULL),
       mask_layer_id_(-1),
       replica_layer_id_(-1),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
       anchor_point_(0.5f, 0.5f),
       anchor_point_z_(0.f),
       scroll_offset_delegate_(NULL),
-      scrollable_(false),
+      clip_layer_(NULL),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       background_color_(0),
       stacking_order_changed_(false),
       double_sided_(true),
       layer_property_changed_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       opacity_(1.0),
       preserves_3d_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       draws_content_(false),
       hide_layer_and_subtree_(false),
       force_render_surface_(false),
       is_container_for_fixed_position_layers_(false),
       draw_depth_(0.f),
       compositing_reasons_(kCompositingReasonUnknown),
-      current_draw_mode_(DRAW_MODE_NONE),
-      horizontal_scrollbar_layer_(NULL),
-      vertical_scrollbar_layer_(NULL) {
+      current_draw_mode_(DRAW_MODE_NONE) {
   DCHECK_GT(layer_id_, 0);
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
   AnimationRegistrar* registrar = layer_tree_impl_->animationRegistrar();
   layer_animation_controller_ =
       registrar->GetAnimationControllerForId(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
 }
 
 LayerImpl::~LayerImpl() {
@@ skipping 271 matching lines @@
   if (!user_scrollable_horizontal_) {
     scroll_hidden.set_x(scroll.x());
     scroll.set_x(0.f);
   }
   if (!user_scrollable_vertical_) {
     scroll_hidden.set_y(scroll.y());
     scroll.set_y(0.f);
   }
 
   gfx::Vector2dF min_delta = -scroll_offset_;
-  gfx::Vector2dF max_delta = max_scroll_offset_ - scroll_offset_;
+  gfx::Vector2dF max_delta = MaxScrollOffset() - scroll_offset_;
   // Clamp new_delta so that position + delta stays within scroll bounds.
   gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
   new_delta.SetToMax(min_delta);
   new_delta.SetToMin(max_delta);
   gfx::Vector2dF unscrolled =
       ScrollDelta() + scroll + scroll_hidden - new_delta;
   SetScrollDelta(new_delta);
+
   return unscrolled;
 }
 
+void LayerImpl::SetScrollable(int clip_layer_id) {

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

As I said on the other patch, I think this is a somewhat awkward name.

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

Let's try "SetScrollClipLayer", sound ok?

Fixed in both patches.

+  clip_layer_ = layer_tree_impl()->LayerById(clip_layer_id);
+}
+
 void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
 
   // Apply sent scroll deltas to scroll position / scroll delta as if the
   // main thread had applied them and then committed those values.
   //
   // This function should not change the total scroll offset; it just shifts
   // some of the scroll delta to the scroll offset.  Therefore, adjust these
   // variables directly rather than calling the scroll offset delegate to
@@ skipping 69 matching lines @@
   if (type == InputHandler::Wheel && have_wheel_event_handlers()) {
     TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
     return InputHandler::ScrollOnMainThread;
   }
 
   if (!scrollable()) {
     TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
     return InputHandler::ScrollIgnored;
   }
 
-  if (max_scroll_offset_.x() <= 0 && max_scroll_offset_.y() <= 0) {
+  gfx::Vector2d max_scroll_offset = MaxScrollOffset();
+  if (max_scroll_offset.x() <= 0 && max_scroll_offset.y() <= 0) {
     TRACE_EVENT0("cc",
                  "LayerImpl::tryScroll: Ignored. Technically scrollable,"
                  " but has no affordance in either direction.");
     return InputHandler::ScrollIgnored;
   }
 
   if (!user_scrollable_horizontal_ && !user_scrollable_vertical_) {
     TRACE_EVENT0("cc",
                  "LayerImpl::TryScroll: Ignored. User gesture is not allowed"
                  " to scroll this layer.");
@@ skipping 57 matching lines @@
   layer->SetPosition(position_);
   layer->SetIsContainerForFixedPositionLayers(
       is_container_for_fixed_position_layers_);
   layer->SetFixedContainerSizeDelta(fixed_container_size_delta_);
   layer->SetPositionConstraint(position_constraint_);
   layer->SetPreserves3d(preserves_3d());
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);
   layer->SetTransform(transform_);
 
-  layer->SetScrollable(scrollable_);
+  layer->SetScrollable(clip_layer_ ? clip_layer_->id() : Layer::INVALID_ID);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
   layer->SetScrollOffsetAndDelta(
       scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2d());
 
-  layer->SetMaxScrollOffset(max_scroll_offset_);
-
   LayerImpl* scroll_parent = NULL;
   if (scroll_parent_)
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
 
   layer->SetScrollParent(scroll_parent);
   if (scroll_children_) {
     std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>;
     for (std::set<LayerImpl*>::iterator it = scroll_children_->begin();
         it != scroll_children_->end(); ++it)
       scroll_children->insert(layer->layer_tree_impl()->LayerById((*it)->id()));
@@ skipping 50 matching lines @@
   gfx_transform.matrix().asColMajord(transform);
   list = new base::ListValue;
   for (int i = 0; i < 16; ++i)
     list->AppendDouble(transform[i]);
   result->Set("DrawTransform", list);
 
   result->SetBoolean("DrawsContent", draws_content_);
   result->SetDouble("Opacity", opacity());
   result->SetBoolean("ContentsOpaque", contents_opaque_);
 
-  if (scrollable_)
-    result->SetBoolean("Scrollable", scrollable_);
+  if (scrollable())
+    result->SetBoolean("Scrollable", true);
 
   if (have_wheel_event_handlers_)
     result->SetBoolean("WheelHandler", have_wheel_event_handlers_);
   if (!touch_event_handler_region_.IsEmpty()) {
     scoped_ptr<base::Value> region = touch_event_handler_region_.AsValue();
     result->Set("TouchRegion", region.release());
   }
 
   list = new base::ListValue;
   for (size_t i = 0; i < children_.size(); ++i)
@@ skipping 69 matching lines @@
 bool LayerImpl::IsActive() const {
   return layer_tree_impl_->IsActiveTree();
 }
 
 void LayerImpl::SetBounds(gfx::Size bounds) {
   if (bounds_ == bounds)
     return;
 
   bounds_ = bounds;
 
+  NotifyScrollbars();
   if (masks_to_bounds())
     NoteLayerPropertyChangedForSubtree();
   else
     NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
   int new_layer_id = mask_layer ? mask_layer->id() : -1;
 
   if (mask_layer) {
@@ skipping 232 matching lines @@
     float* contents_scale_x,
     float* contents_scale_y,
     gfx::Size* content_bounds) {
   // Base LayerImpl has all of its content scales and content bounds pushed
   // from its Layer during commit and just reuses those values as-is.
   *contents_scale_x = this->contents_scale_x();
   *contents_scale_y = this->contents_scale_y();
   *content_bounds = this->content_bounds();
 }
 
-void LayerImpl::UpdateScrollbarPositions() {
-  gfx::Vector2dF current_offset = scroll_offset_ + ScrollDelta();
-
-  gfx::RectF viewport(PointAtOffsetFromOrigin(current_offset), bounds_);
-  gfx::SizeF scrollable_size(max_scroll_offset_.x() + bounds_.width(),
-                             max_scroll_offset_.y() + bounds_.height());
-  if (horizontal_scrollbar_layer_) {
-    horizontal_scrollbar_layer_->SetCurrentPos(current_offset.x());
-    horizontal_scrollbar_layer_->SetMaximum(max_scroll_offset_.x());
-    horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(
-        viewport.width() / scrollable_size.width());
-  }
-  if (vertical_scrollbar_layer_) {
-    vertical_scrollbar_layer_->SetCurrentPos(current_offset.y());
-    vertical_scrollbar_layer_->SetMaximum(max_scroll_offset_.y());
-    vertical_scrollbar_layer_->SetVisibleToTotalLengthRatio(
-        viewport.height() / scrollable_size.height());
-  }
-
-  if (current_offset == last_scroll_offset_)
-    return;
-  last_scroll_offset_ = current_offset;
-
-  if (scrollbar_animation_controller_) {
-    bool should_animate = scrollbar_animation_controller_->DidScrollUpdate(
-        layer_tree_impl_->CurrentPhysicalTimeTicks());
-    if (should_animate)
-      layer_tree_impl_->StartScrollbarAnimation();
-  }
-
-  // Get the current_offset_.y() value for a sanity-check on scrolling
-  // benchmark metrics. Specifically, we want to make sure
-  // BasicMouseWheelSmoothScrollGesture has proper scroll curves.
-  if (layer_tree_impl()->IsActiveTree()) {
-    TRACE_COUNTER_ID1("gpu", "scroll_offset_y", this->id(), current_offset.y());
-  }
-}
-
 void LayerImpl::SetScrollOffsetDelegate(
     LayerScrollOffsetDelegate* scroll_offset_delegate) {
   // Having both a scroll parent and a scroll offset delegate is unsupported.
   DCHECK(!scroll_parent_);
   if (!scroll_offset_delegate && scroll_offset_delegate_) {
     scroll_delta_ =
         scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
   }
   gfx::Vector2dF total_offset = TotalScrollOffset();
   scroll_offset_delegate_ = scroll_offset_delegate;
-  if (scroll_offset_delegate_) {
-    scroll_offset_delegate_->SetMaxScrollOffset(max_scroll_offset_);
+  if (scroll_offset_delegate_)
     scroll_offset_delegate_->SetTotalScrollOffset(total_offset);
-  }
 }
 
 bool LayerImpl::IsExternalFlingActive() const {
   return scroll_offset_delegate_ &&
          scroll_offset_delegate_->IsExternalFlingActive();
 }
 
 void LayerImpl::SetScrollOffset(gfx::Vector2d scroll_offset) {
   SetScrollOffsetAndDelta(scroll_offset, ScrollDelta());
 }
 
 void LayerImpl::SetScrollOffsetAndDelta(gfx::Vector2d scroll_offset,
                                         gfx::Vector2dF scroll_delta) {
   bool changed = false;
 
+  last_scroll_offset_ = scroll_offset;

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

What is last_scroll_offset_ used for?

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

Ooops, remnant of diagnostic code :-)

Removed.

+
   if (scroll_offset_ != scroll_offset) {
     changed = true;
     scroll_offset_ = scroll_offset;
 
     if (scroll_offset_delegate_)
       scroll_offset_delegate_->SetTotalScrollOffset(TotalScrollOffset());
   }
 
   if (ScrollDelta() != scroll_delta) {
     changed = true;
@@ skipping 14 matching lines @@
     if (scroll_offset_delegate_) {
       scroll_offset_delegate_->SetTotalScrollOffset(scroll_offset_ +
                                                     scroll_delta);
     } else {
       scroll_delta_ = scroll_delta;
     }
   }
 
   if (changed) {
     NoteLayerPropertyChangedForSubtree();
-    UpdateScrollbarPositions();
+    NotifyScrollbars();
   }
 }
 
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
   if (scroll_offset_delegate_)
     return scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
   return scroll_delta_;
 }
 
 void LayerImpl::SetScrollDelta(gfx::Vector2dF scroll_delta) {
@@ skipping 15 matching lines @@
 Region LayerImpl::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return visible_content_rect();
   return Region();
 }
 
 void LayerImpl::DidBeginTracing() {}
 
 void LayerImpl::DidLoseOutputSurface() {}
 
-void LayerImpl::SetMaxScrollOffset(gfx::Vector2d max_scroll_offset) {
-  if (max_scroll_offset_ == max_scroll_offset)
-    return;
-  max_scroll_offset_ = max_scroll_offset;
+gfx::Vector2d LayerImpl::MaxScrollOffset() const {
+  if (!clip_layer_)
+    return gfx::Vector2d();
 
-  if (scroll_offset_delegate_)
-    scroll_offset_delegate_->SetMaxScrollOffset(max_scroll_offset_);
+  gfx::Size scaled_scroll_bounds(bounds());
+  LayerImpl const* current_layer = this;
+  LayerImpl const* page_scale_layer = layer_tree_impl()->page_scale_layer();
+  float scale_factor = 1.f;
+  do {

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

This loop assumes there are no other scale transforms in the tree.  I think that
is reasonable in practice, but in theory this is not general enough.  I think
you either need to be more general or assert your assumptions.  (This is true
for the position function below as well.)

The more general option here is to use screen space transforms here and map one
layer into the space of the other. You could maybe cache this value somewhere
else so you don't have a map every time MaxScrollOffset is called.

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

I've made this more general, allow scale (but not translation) on the layers
between the scroll and clip layers. I've used DCHECKs to enforce the
assumptions.

+    if (current_layer == page_scale_layer) {
+      scale_factor = layer_tree_impl()->total_page_scale_factor();
+      scaled_scroll_bounds.SetSize(
+          scale_factor * scaled_scroll_bounds.width(),
+          scale_factor * scaled_scroll_bounds.height());
+    }
+    current_layer = current_layer->parent();
+  } while (current_layer && current_layer != clip_layer_);
+  DCHECK(current_layer == clip_layer_);
 
-  layer_tree_impl()->set_needs_update_draw_properties();
-  UpdateScrollbarPositions();
+  gfx::Vector2dF max_offset(
+      scaled_scroll_bounds.width() - clip_layer_->bounds().width(),

[aelias_OOO_until_Jul13, 2013/11/14 01:25:35]

Using clip_layer_->bounds() is incorrect on Android where the viewport size is
dynamic due to URL-bar hiding.  This only works when the clip layer
masksToBounds.  (I renamed it to containerLayer in most places because it
doesn't necessarily clip.)  For the inner viewport, the calculation in
LayerTreeHostImpl::UnscaledScrollableViewportSize() should be used instead.

+      scaled_scroll_bounds.height() - clip_layer_->bounds().height());
+  // We need the final scroll offset to be in CSS coords.
+  max_offset.Scale(1 / scale_factor);
+  return gfx::Vector2d(max_offset.x(), max_offset.y());
+}
+
+gfx::Vector2dF LayerImpl::ClampScrollToMaxScrollOffset() {
+  gfx::Vector2dF max_offset = MaxScrollOffset();
+  gfx::Vector2dF old_offset = TotalScrollOffset();
+  gfx::Vector2dF clamped_offset = old_offset;
+
+  clamped_offset.SetToMin(max_offset);
+  clamped_offset.SetToMax(gfx::Vector2d());
+  gfx::Vector2dF delta = clamped_offset - old_offset;
+  if (!delta.IsZero())
+    ScrollBy(delta);
+
+  return delta;
+}
+
+void LayerImpl::SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
+                                     LayerImpl* scrollbar_clip_layer) const {
+  DCHECK(scrollbar_layer);
+  LayerImpl* page_scale_layer = layer_tree_impl()->page_scale_layer();
+
+  DCHECK(scrollbar_clip_layer);
+  gfx::RectF clip_rect(gfx::PointF(), scrollbar_clip_layer->bounds());
+  gfx::RectF scroll_rect(gfx::PointF(), bounds());
+
+  gfx::Vector2dF current_offset;
+
+  // TODO(wjmaclean): How do I account for vertical adjust, or do I need to?

[aelias_OOO_until_Jul13, 2013/11/14 01:25:35]

"Vertical adjust" is used to keep the horizontal scrollbars at a stable position
at the bottom of the screen while the URL-bar is moving.  (The renderer
compositor's viewport always starts 1px below the URL-bar -- the browser
compositor takes care of the translation -- so the horizontal scrollbar must
move vertically to appear to remain at a fixed spot.)

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

Done.

+  // Also, I can probably improve some of the variable names.
+  LayerImpl const* current_layer = this;
+  float scale_factor = 1.f;
+  do {
+    if (current_layer == page_scale_layer) {
+      scale_factor = layer_tree_impl()->total_page_scale_factor();
+      current_offset.Scale(scale_factor);
+      scroll_rect.Scale(scale_factor);
+      current_offset.Scale(scale_factor);
+    } else {
+      gfx::Vector2dF new_offset =
+          current_layer->scroll_offset() + current_layer->ScrollDelta();
+      current_offset += new_offset;
+    }
+    current_layer = current_layer->parent();
+  } while (current_layer && current_layer != scrollbar_clip_layer);
+  DCHECK(current_layer == scrollbar_clip_layer);
+  current_offset.Scale(1 / scale_factor);
+
+  if (scrollbar_layer->orientation() == HORIZONTAL) {
+    float visible_ratio = clip_rect.width() / scroll_rect.width();
+    scrollbar_layer->SetCurrentPos(current_offset.x());
+    scrollbar_layer->SetMaximum(scroll_rect.width() - clip_rect.width());
+    scrollbar_layer->SetVisibleToTotalLengthRatio(visible_ratio);
+  } else {
+    float visible_ratio = clip_rect.height() / scroll_rect.height();
+    scrollbar_layer->SetCurrentPos(current_offset.y());
+    scrollbar_layer->SetMaximum(scroll_rect.height() - clip_rect.height());
+    scrollbar_layer->SetVisibleToTotalLengthRatio(visible_ratio);
+  }
+
+  // TODO(wjmaclean) The scrollbar animator for the pinch-zoom scrollbars should
+  // activate for every scroll on the main frame, not just the scrolls that move
+  // the pinch virtual viewport.
+  if (scrollbar_animation_controller_) {
+    bool should_animate = scrollbar_animation_controller_->DidScrollUpdate(
+        layer_tree_impl_->CurrentPhysicalTimeTicks());
+    if (should_animate)
+      layer_tree_impl_->StartScrollbarAnimation();
+  }
 }
 
 void LayerImpl::DidBecomeActive() {
   if (layer_tree_impl_->settings().scrollbar_animator ==
       LayerTreeSettings::NoAnimator) {
     return;
   }
 
-  bool need_scrollbar_animation_controller = horizontal_scrollbar_layer_ ||
-                                             vertical_scrollbar_layer_;
+  bool need_scrollbar_animation_controller = scrollable() && scrollbars_;
   if (!need_scrollbar_animation_controller) {
     scrollbar_animation_controller_.reset();
     return;
   }
 
   if (scrollbar_animation_controller_)
     return;
 
   switch (layer_tree_impl_->settings().scrollbar_animator) {
   case LayerTreeSettings::LinearFade: {
@@ skipping 12 matching lines @@
     scrollbar_animation_controller_ =
         ScrollbarAnimationControllerThinning::Create(this)
             .PassAs<ScrollbarAnimationController>();
     break;
   }
   case LayerTreeSettings::NoAnimator:
     NOTREACHED();
     break;
   }
 }
-void LayerImpl::SetHorizontalScrollbarLayer(
-    ScrollbarLayerImplBase* scrollbar_layer) {
-  horizontal_scrollbar_layer_ = scrollbar_layer;
-  if (horizontal_scrollbar_layer_)
-    horizontal_scrollbar_layer_->set_scroll_layer_id(id());
+
+void LayerImpl::ClearScrollbars() {
+  if (!scrollbars_)
+    return;
+
+  scrollbars_.reset(NULL);
 }
 
-void LayerImpl::SetVerticalScrollbarLayer(
-    ScrollbarLayerImplBase* scrollbar_layer) {
-  vertical_scrollbar_layer_ = scrollbar_layer;
-  if (vertical_scrollbar_layer_)
-    vertical_scrollbar_layer_->set_scroll_layer_id(id());
+void LayerImpl::AddScrollbar(ScrollbarLayerImplBase* layer) {
+  DCHECK(layer);
+  if (!scrollbars_)
+    scrollbars_.reset(new ScrollbarSet());
+
+  scrollbars_->insert(layer);
+}
+
+void LayerImpl::RemoveScrollbar(ScrollbarLayerImplBase* layer) {
+  DCHECK(scrollbars_);
+  DCHECK(layer);
+
+  scrollbars_->erase(layer);
+  if (scrollbars_->empty())
+    scrollbars_.reset();
+}
+
+bool LayerImpl::HasScrollbar(ScrollbarOrientation orientation) const {
+  if (!scrollbars_)
+    return false;
+
+  for (ScrollbarSet::iterator it = scrollbars_->begin();
+       it != scrollbars_->end(); ++it)
+    if ((*it)->orientation() == orientation)
+      return true;
+
+  return false;
+}
+
+void LayerImpl::NotifyScrollbars() {
+  if (!scrollbars_)
+    return;
+
+  for (ScrollbarSet::iterator it = scrollbars_->begin();
+       it != scrollbars_->end(); ++it)
+    (*it)->ScrollbarParametersDidChange();
 }
 
 static scoped_ptr<base::Value>
 CompositingReasonsAsValue(CompositingReasons reasons) {
   scoped_ptr<base::ListValue> reason_list(new base::ListValue());
 
   if (reasons == kCompositingReasonUnknown) {
     reason_list->AppendString("No reasons given");
     return reason_list.PassAs<base::Value>();
   }
@@ skipping 165 matching lines @@
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc