Adding momentum/overscroll to views:: ScrollViews

ui/views/controls/scroll_view.cc

 // Copyright (c) 2012 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 "ui/views/controls/scroll_view.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "ui/compositor/overscroll/ui_scroll_input_manager.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme.h"
+#include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/style/platform_style.h"
-#include "ui/views/widget/root_view.h"
+#include "ui/views/widget/widget.h"
 
 namespace views {
 
 const char ScrollView::kViewClassName[] = "ScrollView";
 
 namespace {
 
 // Subclass of ScrollView that resets the border when the theme changes.
 class ScrollViewWithBorder : public views::ScrollView {
  public:
@@ skipping 32 matching lines @@
 int CheckScrollBounds(int viewport_size, int content_size, int current_pos) {
   int max = std::max(content_size - viewport_size, 0);
   if (current_pos < 0)
     return 0;
   if (current_pos > max)
     return max;
   return current_pos;
 }
 
 // Make sure the content is not scrolled out of bounds
-void CheckScrollBounds(View* viewport, View* view) {
+void CheckScrollBounds(View* viewport, View* container, View* view) {
   if (!view)
     return;
 
-  int x = CheckScrollBounds(viewport->width(), view->width(), -view->x());
-  int y = CheckScrollBounds(viewport->height(), view->height(), -view->y());
+  gfx::ScrollOffset offset = container
+                                 ? container->layer()->CurrentScrollOffset()
+                                 : gfx::ScrollOffset(-view->x(), -view->y());
 
-  // This is no op if bounds are the same
-  view->SetBounds(-x, -y, view->width(), view->height());
+  int x = CheckScrollBounds(viewport->width(), view->width(), offset.x());
+  int y = CheckScrollBounds(viewport->height(), view->height(), offset.y());
+
+  if (container) {
+    container->layer()->SetScrollOffset(gfx::ScrollOffset(x, y));
+  } else {
+    // This is no op if bounds are the same
+    view->SetBounds(-x, -y, view->width(), view->height());
+  }
 }
 
 // Used by ScrollToPosition() to make sure the new position fits within the
 // allowed scroll range.
 int AdjustPosition(int current_position,
                    int new_position,
                    int content_size,
                    int viewport_size) {
   if (-current_position == new_position)
     return new_position;
   if (new_position < 0)
     return 0;
   const int max_position = std::max(0, content_size - viewport_size);
   return (new_position > max_position) ? max_position : new_position;
 }
 
+class ScrollViewContainer : public View {
+ public:
+  ScrollViewContainer() {}
+
+  // View:
+  void ChildPreferredSizeChanged(View* child) override {
+    PreferredSizeChanged();
+  }
+
+  // TODO: Add ScrollRectToVisible
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScrollViewContainer);
+};
+
 }  // namespace
 
 // Viewport contains the contents View of the ScrollView.
 class ScrollView::Viewport : public View {
  public:
   Viewport() {}
   ~Viewport() override {}
 
   const char* GetClassName() const override { return "ScrollView::Viewport"; }
 
   void ScrollRectToVisible(const gfx::Rect& rect) override {
     if (!has_children() || !parent())
       return;
 
     View* contents = child_at(0);
     gfx::Rect scroll_rect(rect);
+
+    ScrollView* scroll_view = static_cast<ScrollView*>(parent());
+    if (contents == scroll_view->contents_container_) {
+      // With layer scrolling, there's no need to "undo" the offset done in the
+      // child's View::ScrollRectToVisible() before it calls this.
+      DCHECK_EQ(0, contents->x());
+      DCHECK_EQ(0, contents->y());
+    }
+
     scroll_rect.Offset(-contents->x(), -contents->y());
-    static_cast<ScrollView*>(parent())->ScrollContentsRegionToBeVisible(
-        scroll_rect);
+    scroll_view->ScrollContentsRegionToBeVisible(scroll_rect);
   }
 
   void ChildPreferredSizeChanged(View* child) override {
     if (parent())
       parent()->Layout();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Viewport);
 };
 
 ScrollView::ScrollView()
     : contents_(NULL),
+      contents_container_(new ScrollViewContainer()),
       contents_viewport_(new Viewport()),
       header_(NULL),
       header_viewport_(new Viewport()),
       horiz_sb_(PlatformStyle::CreateScrollBar(true).release()),
       vert_sb_(PlatformStyle::CreateScrollBar(false).release()),
       corner_view_(new ScrollCornerView()),
       min_height_(-1),
       max_height_(-1),
       hide_horizontal_scrollbar_(false) {
   set_notify_enter_exit_on_child(true);
 
   AddChildView(contents_viewport_);
+  contents_viewport_->AddChildView(contents_container_);
   AddChildView(header_viewport_);
 
   // Don't add the scrollbars as children until we discover we need them
   // (ShowOrHideScrollBar).
   horiz_sb_->SetVisible(false);
   horiz_sb_->set_controller(this);
   vert_sb_->SetVisible(false);
   vert_sb_->set_controller(this);
   corner_view_->SetVisible(false);
+
+  contents_viewport_->SetPaintToLayer(true);
+  contents_viewport_->set_background(
+      Background::CreateSolidBackground(SK_ColorWHITE));
+  contents_viewport_->layer()->SetMasksToBounds(true);
+
+  contents_container_->SetPaintToLayer(true);
+  contents_container_->set_background(
+      Background::CreateSolidBackground(SK_ColorWHITE));
+  contents_container_->layer()->SetScrollable(
+      contents_viewport_->layer(), true /* can_overscroll */,
+      base::Bind(&ScrollView::OnLayerScrolled, base::Unretained(this)));
 }
 
 ScrollView::~ScrollView() {
   // The scrollbars may not have been added, delete them to ensure they get
   // deleted.
   delete horiz_sb_;
   delete vert_sb_;
   delete corner_view_;
 }
 
 // static
 ScrollView* ScrollView::CreateScrollViewWithBorder() {
   return new ScrollViewWithBorder();
 }
 
 void ScrollView::SetContents(View* a_view) {
-  SetHeaderOrContents(contents_viewport_, a_view, &contents_);
+  SetHeaderOrContents(contents_container_, a_view, &contents_);
 }
 
 void ScrollView::SetHeader(View* header) {
   SetHeaderOrContents(header_viewport_, header, &header_);
 }
 
 gfx::Rect ScrollView::GetVisibleRect() const {
   if (!contents_)
     return gfx::Rect();
-  return gfx::Rect(-contents_->x(), -contents_->y(),
-                   contents_viewport_->width(), contents_viewport_->height());
+  gfx::ScrollOffset offset = CurrentOffset();
+  return gfx::Rect(offset.x(), offset.y(), contents_viewport_->width(),
+                   contents_viewport_->height());
 }
 
 void ScrollView::ClipHeightTo(int min_height, int max_height) {
   min_height_ = min_height;
   max_height_ = max_height;
 }
 
 int ScrollView::GetScrollBarWidth() const {
   return vert_sb_ ? vert_sb_->GetLayoutSize() : 0;
 }
@@ skipping 77 matching lines @@
   // viewport_size is the total client space available.
   gfx::Size viewport_size = viewport_bounds.size();
   // Assumes a vertical scrollbar since most of the current views are designed
   // for this.
   int horiz_sb_height = GetScrollBarHeight();
   int vert_sb_width = GetScrollBarWidth();
   viewport_bounds.set_width(viewport_bounds.width() - vert_sb_width);
   // Update the bounds right now so the inner views can fit in it.
   contents_viewport_->SetBoundsRect(viewport_bounds);
 
-  // Give |contents_| a chance to update its bounds if it depends on the
-  // viewport.
-  if (contents_)
+  // Give |contents_| a chance to update its bounds if it depends on its parent
+  // bounds.
+  if (contents_) {
+    // The container bounds may need to be made larger later, but use the
+    // viewport bounds to layout the contents.
+    contents_container_->SetBoundsRect(viewport_bounds);
     contents_->Layout();
+  }
 
   bool should_layout_contents = false;
   bool horiz_sb_required = false;
   bool vert_sb_required = false;
   if (contents_) {
     gfx::Size content_size = contents_->size();
     ComputeScrollBarsVisibility(viewport_size,
                                 content_size,
                                 &horiz_sb_required,
                                 &vert_sb_required);
@@ skipping 35 matching lines @@
                         viewport_bounds.bottom() - contents_y - height_offset);
   }
   if (corner_view_required) {
     // Show the resize corner.
     corner_view_->SetBounds(vert_sb_->bounds().x(), horiz_sb_->bounds().y(),
                             vert_sb_width, horiz_sb_height);
   }
 
   // Update to the real client size with the visible scrollbars.
   contents_viewport_->SetBoundsRect(viewport_bounds);
-  if (should_layout_contents && contents_)
+  if (should_layout_contents && contents_) {
+    contents_container_->SetBoundsRect(viewport_bounds);
     contents_->Layout();
+  }
+
+  // Even when |contents_| needs to scroll, it can still be narrower or wider
+  // the viewport. So ensure the scrolling layer can fill the viewport, so that
+  // events will correctly hit it, and overscroll looks correct.
+  gfx::Size container_size = contents_ ? contents_->size() : gfx::Size();
+  container_size.SetToMax(viewport_bounds.size());
+  contents_container_->SetBoundsRect(gfx::Rect(container_size));
 
   header_viewport_->SetBounds(contents_x, contents_y,
                               viewport_bounds.width(), header_height);
   if (header_)
     header_->Layout();
 
-  CheckScrollBounds(header_viewport_, header_);
-  CheckScrollBounds(contents_viewport_, contents_);
+  CheckScrollBounds(header_viewport_, nullptr, header_);
+  CheckScrollBounds(contents_viewport_, contents_container_, contents_);
+
   SchedulePaint();
   UpdateScrollBarPositions();
 }
 
 bool ScrollView::OnKeyPressed(const ui::KeyEvent& event) {
   bool processed = false;
 
   // Give vertical scrollbar priority
   if (vert_sb_->visible())
     processed = vert_sb_->OnKeyPressed(event);
@@ skipping 23 matching lines @@
     vert_sb_->OnMouseEnteredScrollView(event);
 }
 
 void ScrollView::OnMouseExited(const ui::MouseEvent& event) {
   if (horiz_sb_)
     horiz_sb_->OnMouseExitedScrollView(event);
   if (vert_sb_)
     vert_sb_->OnMouseExitedScrollView(event);
 }
 
+void ScrollView::OnScrollEvent(ui::ScrollEvent* event) {
+  ui::UIScrollInputManager* compositor_scroller =
+      GetWidget()->GetCompositor()->scroll_input_manager();
+  if (compositor_scroller)
+    compositor_scroller->OnScrollEvent(*event);
+}
+
 void ScrollView::OnGestureEvent(ui::GestureEvent* event) {
   // If the event happened on one of the scrollbars, then those events are
   // sent directly to the scrollbars. Otherwise, only scroll events are sent to
   // the scrollbars.
   bool scroll_event = event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
                       event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
                       event->type() == ui::ET_GESTURE_SCROLL_END ||
                       event->type() == ui::ET_SCROLL_FLING_START;
 
   if (vert_sb_->visible()) {
     if (vert_sb_->bounds().Contains(event->location()) || scroll_event)
       vert_sb_->OnGestureEvent(event);
   }
   if (!event->handled() && horiz_sb_->visible()) {
     if (horiz_sb_->bounds().Contains(event->location()) || scroll_event)
       horiz_sb_->OnGestureEvent(event);
   }
 }
 
 const char* ScrollView::GetClassName() const {
   return kViewClassName;
 }
 
+ScrollView* ScrollView::EnclosingScrollView() {
+  return this;
+}
+
 void ScrollView::ScrollToPosition(ScrollBar* source, int position) {
   if (!contents_)
     return;
 
+  gfx::ScrollOffset offset = CurrentOffset();
   if (source == horiz_sb_ && horiz_sb_->visible()) {
-    position = AdjustPosition(contents_->x(), position, contents_->width(),
+    position = AdjustPosition(offset.x(), position, contents_->width(),
                               contents_viewport_->width());
-    if (-contents_->x() == position)
+    if (offset.x() == position)
       return;
-    contents_->SetX(-position);
-    if (header_) {
-      header_->SetX(-position);
-      header_->SchedulePaintInRect(header_->GetVisibleBounds());
-    }
+    offset.set_x(position);
   } else if (source == vert_sb_ && vert_sb_->visible()) {
-    position = AdjustPosition(contents_->y(), position, contents_->height(),
+    position = AdjustPosition(offset.y(), position, contents_->height(),
                               contents_viewport_->height());
-    if (-contents_->y() == position)
+    if (offset.y() == position)
       return;
-    contents_->SetY(-position);
+    offset.set_y(position);
   }
+  ScrollToOffset(offset);
+
+  // TODO(tapted): Remove. Not needed for layered scrolling.
   contents_->SchedulePaintInRect(contents_->GetVisibleBounds());
 }
 
 int ScrollView::GetScrollIncrement(ScrollBar* source, bool is_page,
                                    bool is_positive) {
   bool is_horizontal = source->IsHorizontal();
   int amount = 0;
   if (contents_) {
     if (is_page) {
       amount = contents_->GetPageScrollIncrement(
@@ skipping 61 matching lines @@
   // corner. This is done by setting the offset to -X or -Y.  For down
   // or right shifts we need to make sure it appears in the
   // lower/right corner. This is calculated by taking max_x or max_y
   // and scaling it back by the size of the viewport.
   const int new_x =
       (vis_rect.x() > x) ? x : std::max(0, max_x - contents_viewport_->width());
   const int new_y =
       (vis_rect.y() > y) ? y : std::max(0, max_y -
                                         contents_viewport_->height());
 
-  contents_->SetX(-new_x);
-  if (header_)
-    header_->SetX(-new_x);
-  contents_->SetY(-new_y);
+  ScrollToOffset(gfx::ScrollOffset(new_x, new_y));
+
+  // TODO(tapted): Remove. Handled in OnLayerScrolled() with layered scrolling.
   UpdateScrollBarPositions();
 }
 
 void ScrollView::ComputeScrollBarsVisibility(const gfx::Size& vp_size,
                                              const gfx::Size& content_size,
                                              bool* horiz_is_shown,
                                              bool* vert_is_shown) const {
   // Try to fit both ways first, then try vertical bar only, then horizontal
   // bar only, then defaults to both shown.
   if (content_size.width() <= vp_size.width() &&
@@ skipping 27 matching lines @@
   } else {
     RemoveChildView(control);
     control->SetVisible(false);
   }
 }
 
 void ScrollView::UpdateScrollBarPositions() {
   if (!contents_)
     return;
 
+  const gfx::ScrollOffset offset = CurrentOffset();
   if (horiz_sb_->visible()) {
     int vw = contents_viewport_->width();
     int cw = contents_->width();
-    int origin = contents_->x();
-    horiz_sb_->Update(vw, cw, -origin);
+    horiz_sb_->Update(vw, cw, offset.x());
   }
   if (vert_sb_->visible()) {
     int vh = contents_viewport_->height();
     int ch = contents_->height();
-    int origin = contents_->y();
-    vert_sb_->Update(vh, ch, -origin);
+    vert_sb_->Update(vh, ch, offset.y());
   }
 }
 
+gfx::ScrollOffset ScrollView::CurrentOffset() const {
+  return contents_container_->layer()->CurrentScrollOffset();
+}
+
+void ScrollView::ScrollToOffset(const gfx::ScrollOffset& offset) {
+  contents_container_->layer()->SetScrollOffset(offset);
+  OnLayerScrolled();
+}
+
+void ScrollView::OnLayerScrolled() {
+  if (header_) {
+    header_->SetX(-CurrentOffset().x());
+    header_->SchedulePaintInRect(header_->GetVisibleBounds());
+  }
+  UpdateScrollBarPositions();
+}
+
 // VariableRowHeightScrollHelper ----------------------------------------------
 
 VariableRowHeightScrollHelper::VariableRowHeightScrollHelper(
     Controller* controller) : controller_(controller) {
 }
 
 VariableRowHeightScrollHelper::~VariableRowHeightScrollHelper() {
 }
 
 int VariableRowHeightScrollHelper::GetPageScrollIncrement(
@@ skipping 54 matching lines @@
 
 VariableRowHeightScrollHelper::RowInfo
     FixedRowHeightScrollHelper::GetRowInfo(int y) {
   if (y < top_margin_)
     return RowInfo(0, top_margin_);
   return RowInfo((y - top_margin_) / row_height_ * row_height_ + top_margin_,
                  row_height_);
 }
 
 }  // namespace views