Move viewport scrolling logic into separate class

cc/layers/viewport.cc

Index: cc/layers/viewport.cc
diff --git a/cc/layers/viewport.cc b/cc/layers/viewport.cc
new file mode 100644
index 0000000000000000000000000000000000000000..944f1bbd3cfc45012f17cfcca4173faf164cb3ae
--- /dev/null
+++ b/cc/layers/viewport.cc
@@ -0,0 +1,133 @@
+// Copyright 2015 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/viewport.h"
+
+#include "base/logging.h"
+#include "cc/input/top_controls_manager.h"
+#include "cc/trees/layer_tree_host_impl.h"
+#include "cc/trees/layer_tree_impl.h"
+#include "ui/gfx/geometry/vector2d_conversions.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace cc {
+
+// static
+scoped_ptr<Viewport> Viewport::Create(
+    LayerTreeHostImpl* host_impl) {
+  return make_scoped_ptr(new Viewport(host_impl));
+}
+
+Viewport::Viewport(LayerTreeHostImpl* host_impl)
+    : host_impl_(host_impl) {
+  DCHECK(host_impl_);
+}
+
+Viewport::ScrollResult Viewport::ScrollBy(const gfx::Vector2dF& delta,
+                                          const gfx::Point& viewport_point,
+                                          bool is_wheel_scroll) {
+  gfx::Vector2dF content_delta = delta;
+  ScrollResult result;
+
+  if (ShouldTopControlsConsumeScroll(delta)) {
+    result.top_controls_applied_delta = ScrollTopControls(delta);
+    content_delta -= result.top_controls_applied_delta;
+  }
+
+  gfx::Vector2dF pending_content_delta = content_delta;
+
+  if (OuterScrollLayer()) {
+    pending_content_delta -= host_impl_->ScrollLayer(OuterScrollLayer(),
+                                                     pending_content_delta,
+                                                     viewport_point,
+                                                     is_wheel_scroll);
+  }
+
+  // TODO(bokan): This shouldn't be needed but removing it causes subtle
+  // viewport movement during top controls manipulation.
+  if (!gfx::ToRoundedVector2d(pending_content_delta).IsZero()) {
+    pending_content_delta -= host_impl_->ScrollLayer(InnerScrollLayer(),
+                                                     pending_content_delta,
+                                                     viewport_point,
+                                                     is_wheel_scroll);
+    result.unused_scroll_delta = AdjustOverscroll(pending_content_delta);
+  }
+
+
+  result.applied_delta = content_delta - pending_content_delta;
+  return result;
+}
+
+gfx::Vector2dF Viewport::ScrollTopControls(const gfx::Vector2dF& delta) {
+  gfx::Vector2dF excess_delta =
+      host_impl_->top_controls_manager()->ScrollBy(delta);
+
+  return delta - excess_delta;
+}
+
+bool Viewport::ShouldTopControlsConsumeScroll(
+    const gfx::Vector2dF& scroll_delta) const {
+  // Always consume if it's in the direction to show the top controls.
+  if (scroll_delta.y() < 0)
+    return true;
+
+  if (TotalScrollOffset().y() < MaxTotalScrollOffset().y())
+    return true;
+
+  return false;
+}
+
+gfx::Vector2dF Viewport::AdjustOverscroll(const gfx::Vector2dF& delta) const {
+  const float kEpsilon = 0.1f;
+  gfx::Vector2dF adjusted = delta;
+
+  if (std::abs(adjusted.x()) < kEpsilon)
+    adjusted.set_x(0.0f);
+  if (std::abs(adjusted.y()) < kEpsilon)
+    adjusted.set_y(0.0f);
+
+  // Disable overscroll on axes which are impossible to scroll.
+  if (host_impl_->settings().report_overscroll_only_for_scrollable_axes) {
+    if (std::abs(MaxTotalScrollOffset().x()) <= kEpsilon ||
+        !InnerScrollLayer()->user_scrollable_horizontal())
+      adjusted.set_x(0.0f);
+    if (std::abs(MaxTotalScrollOffset().y()) <= kEpsilon ||
+        !InnerScrollLayer()->user_scrollable_vertical())
+      adjusted.set_y(0.0f);
+  }
+
+  return adjusted;
+}
+
+gfx::ScrollOffset Viewport::MaxTotalScrollOffset() const {
+  gfx::ScrollOffset offset;
+
+  offset += InnerScrollLayer()->MaxScrollOffset();
+
+  if (OuterScrollLayer())
+    offset += OuterScrollLayer()->MaxScrollOffset();
+
+  return offset;
+}
+
+gfx::ScrollOffset Viewport::TotalScrollOffset() const {
+  gfx::ScrollOffset offset;
+
+  offset += InnerScrollLayer()->CurrentScrollOffset();
+
+  if (OuterScrollLayer())
+    offset += OuterScrollLayer()->CurrentScrollOffset();
+
+  return offset;
+}
+
+LayerImpl* Viewport::InnerScrollLayer() const {
+  return host_impl_->InnerViewportScrollLayer();
+}
+
+LayerImpl* Viewport::OuterScrollLayer() const {
+  return host_impl_->OuterViewportScrollLayer();
+}
+
+}  // namespace cc