Pinch/Zoom Infrastructure & Plumbing CL

cc/layers/layer_impl.cc

Index: cc/layers/layer_impl.cc
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index ede47194937e0a1eb381f73f543bea680853edd0..e619600ef70196d1547e0be2f83ae87bf73d6c14 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -39,7 +39,7 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
       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),
@@ -60,9 +60,7 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
       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);
@@ -354,7 +352,7 @@ gfx::Vector2dF LayerImpl::ScrollBy(gfx::Vector2dF scroll) {
   }
 
   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);
@@ -362,9 +360,24 @@ gfx::Vector2dF LayerImpl::ScrollBy(gfx::Vector2dF scroll) {
   gfx::Vector2dF unscrolled =
       ScrollDelta() + scroll + scroll_hidden - new_delta;
   SetScrollDelta(new_delta);
+/*
+  if (this == layer_tree_impl()->OuterViewportScrollLayer() ||
+      this == layer_tree_impl()->InnerViewportScrollLayer()) {
+    gfx::Vector2dF max = MaxScrollOffset();
+    fprintf(stderr, "wjm: LayerImpl::ScrollBy(%p, %f, %f), unscrolled = (%f,%f)"
+            ", offset = (%d,%d), max = (%f,%f), delta = (%f,%f)\n",
+        this, scroll.x(), scroll.y(), unscrolled.x(), unscrolled.y(),
+        scroll_offset_.x(), scroll_offset_.y(), max.x(), max.y(),
+        new_delta.x(), new_delta.y());
+  }
+*/
   return unscrolled;
 }
 
+void LayerImpl::SetScrollable(int clip_layer_id) {

[enne (OOO), 2013/10/31 18:45:58]

SetScrollable => SetClipLayerId, or possibly just get rid of this entirely and
move this code inside of PushPropertiesTo.

[wjmaclean, 2013/11/13 21:01:29]

Sure, we could re-name it to SetClipLayerId(). Not sure I understand what you
intend when you say "get rid of this entirely", can you clarify? Certainly it
can be encapsulated in PushProperties to (though some tests may want access to
this, e.g. the JSON tree tests).

+  clip_layer_ = layer_tree_impl()->LayerById(clip_layer_id);
+}
+
 void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
@@ -454,7 +467,8 @@ InputHandler::ScrollStatus LayerImpl::TryScroll(
     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.");
@@ -532,15 +546,13 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   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());
@@ -611,8 +623,8 @@ base::DictionaryValue* LayerImpl::LayerTreeAsJson() const {
   result->SetDouble("Opacity", opacity());
   result->SetBoolean("ContentsOpaque", contents_opaque_);
 
-  if (scrollable_)
-    result->SetBoolean("Scrollable", scrollable_);
+  if (scrollable())
+    result->SetBoolean("Scrollable", true);
 
   list = new base::ListValue;
   for (size_t i = 0; i < children_.size(); ++i)
@@ -695,6 +707,7 @@ void LayerImpl::SetBounds(gfx::Size bounds) {
 
   bounds_ = bounds;
 
+  NotifyScrollbars();
   if (masks_to_bounds())
     NoteLayerPropertyChangedForSubtree();
   else
@@ -947,44 +960,6 @@ void LayerImpl::CalculateContentsScale(
   *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.
@@ -993,12 +968,7 @@ void LayerImpl::SetScrollOffsetDelegate(
     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_);
-    scroll_offset_delegate_->SetTotalScrollOffset(total_offset);
-  }
 }
 
 bool LayerImpl::IsExternalFlingActive() const {
@@ -1014,9 +984,14 @@ void LayerImpl::SetScrollOffsetAndDelta(gfx::Vector2d scroll_offset,
                                         gfx::Vector2dF scroll_delta) {
   bool changed = false;
 
+  last_scroll_offset_ = scroll_offset;
+
   if (scroll_offset_ != scroll_offset) {
     changed = true;
     scroll_offset_ = scroll_offset;
+    gfx::Vector2dF max = MaxScrollOffset();
+    if (scroll_offset_.x() > max.x() || scroll_offset_.y() > max.y())
+      fprintf(stderr, "wjm: LI::SetScrollOffsetAndDelta() scroll_offset too large!\n");
 
     if (scroll_offset_delegate_)
       scroll_offset_delegate_->SetTotalScrollOffset(TotalScrollOffset());
@@ -1048,7 +1023,7 @@ void LayerImpl::SetScrollOffsetAndDelta(gfx::Vector2d scroll_offset,
 
   if (changed) {
     NoteLayerPropertyChangedForSubtree();
-    UpdateScrollbarPositions();
+    NotifyScrollbars();
   }
 }
 
@@ -1084,16 +1059,105 @@ 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;
-
-  if (scroll_offset_delegate_)
-    scroll_offset_delegate_->SetMaxScrollOffset(max_scroll_offset_);
+gfx::Vector2d LayerImpl::MaxScrollOffset() const {
+  if (!clip_layer_)
+    return gfx::Vector2d();
+
+  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 {
+    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_);
+
+  gfx::Vector2dF max_offset(
+      scaled_scroll_bounds.width() - clip_layer_->bounds().width(),
+      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?
+  // 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);
+  // TODO(wjmaclean) need to think about the effect the size of the non-overlay
+  // scrollbars have on the scroll size ... the final max value of current_pos
+  // should not exceed maximum(), but it seems to by roughly 
+  // non_overlay_scroll_bar_width / scale_factor.
+
+  if (scrollbar_layer->orientation() == HORIZONTAL) {
+    float visible_ratio = clip_rect.width() / scroll_rect.width();
+    scrollbar_layer->SetCurrentPos(visible_ratio * current_offset.x());
+    scrollbar_layer->SetMaximum(visible_ratio *
+                                (scroll_rect.width() - clip_rect.width()));
+    scrollbar_layer->SetVisibleToTotalLengthRatio(visible_ratio);
+  } else {
+    float visible_ratio = clip_rect.height() / scroll_rect.height();
+    scrollbar_layer->SetCurrentPos(visible_ratio * current_offset.y());
+    scrollbar_layer->SetMaximum(visible_ratio *
+                                (scroll_rect.height() - clip_rect.height()));
+    scrollbar_layer->SetVisibleToTotalLengthRatio(visible_ratio);
+  }
 
-  layer_tree_impl()->set_needs_update_draw_properties();
-  UpdateScrollbarPositions();
+  // 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() {
@@ -1102,8 +1166,7 @@ void LayerImpl::DidBecomeActive() {
     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;
@@ -1136,18 +1199,50 @@ void LayerImpl::DidBecomeActive() {
     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>