Move viewport scrolling logic into separate class

cc/layers/viewport.cc

+// Copyright 2013 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_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::~Viewport() {
+}
+
+void Viewport::SetViewportLayers(LayerImpl* inner_viewport_scroll,
+                                 LayerImpl* outer_viewport_scroll) {
+  inner_scroll_layer_ = inner_viewport_scroll;
+  outer_scroll_layer_ = outer_viewport_scroll;
+}
+
+
+bool Viewport::IsViewportScrollingLayer(LayerImpl* layer) const {
+  if (!layer)
+    return false;
+
+  if (outer_scroll_layer_)
+    return layer == outer_scroll_layer_;
+
+  return layer == inner_scroll_layer_;
+}
+
+bool Viewport::IsViewportLayer(LayerImpl* layer) const {
+  if (!layer)
+    return false;
+
+  return layer == outer_scroll_layer_ ||
+         layer == inner_scroll_layer_;
+}
+
+Viewport::ScrollResult Viewport::ScrollBy(const gfx::Vector2dF& delta,
+                                          const gfx::Point& viewport_point,
+                                          bool is_wheel_scroll) {
+  gfx::Vector2dF pending_delta = delta;
+  ScrollResult result;
+
+  pending_delta -= ScrollTopControls(pending_delta);
+  pending_delta -= ScrollViewport(pending_delta,
+                                  viewport_point,
+                                  is_wheel_scroll);
+
+  result.applied_delta = delta - pending_delta;
+  result.unused_scroll_delta = pending_delta;
+
+  const float kEpsilon = 0.1f;
+  if (std::abs(result.unused_scroll_delta.x()) < kEpsilon)
+    result.unused_scroll_delta.set_x(0.0f);
+  if (std::abs(result.unused_scroll_delta.y()) < kEpsilon)
+    result.unused_scroll_delta.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 ||
+        !inner_scroll_layer_->user_scrollable_horizontal())
+      result.unused_scroll_delta.set_x(0.0f);
+    if (std::abs(MaxTotalScrollOffset().y()) <= kEpsilon ||
+        !inner_scroll_layer_->user_scrollable_vertical())
+      result.unused_scroll_delta.set_y(0.0f);
+  }
+
+  return result;
+}
+
+gfx::Vector2dF Viewport::ScrollViewport(const gfx::Vector2dF& delta,
+                                        const gfx::Point& viewport_point,
+                                        bool is_wheel_scroll) {
+  gfx::Vector2dF pending_delta = delta;
+
+  if (outer_scroll_layer_) {
+    pending_delta -= ScrollLayer(outer_scroll_layer_,
+                                 delta,
+                                 viewport_point,
+                                 is_wheel_scroll);
+  }
+
+  pending_delta -= ScrollLayer(inner_scroll_layer_,
+                               delta,
+                               viewport_point,
+                               is_wheel_scroll);
+
+  return delta - pending_delta;
+}
+
+gfx::Vector2dF Viewport::ScrollLayer(LayerImpl* layer_impl,
+                                     const gfx::Vector2dF& delta,
+                                     const gfx::Point& viewport_point,
+                                     bool is_wheel_scroll) {
+  gfx::Vector2dF applied_delta;
+  if (!is_wheel_scroll) {
+    return host_impl_->ScrollLayerWithViewportSpaceDelta(inner_scroll_layer_,
+                                                         viewport_point,
+                                                         delta);
+  } else {
+    float page_scale_factor =
+        host_impl_->active_tree()->current_page_scale_factor();
+    return host_impl_->ScrollLayerWithLocalDelta(inner_scroll_layer_,
+                                                 delta,
+                                                 page_scale_factor);
+  }
+}
+
+gfx::Vector2dF Viewport::ScrollTopControls(const gfx::Vector2dF& delta) {
+  if (!ShouldTopControlsConsumeScroll(delta))
+    return gfx::Vector2dF();
+
+  gfx::Vector2dF excess_delta =
+      host_impl_->top_controls_manager()->ScrollBy(delta);
+
+  return delta - excess_delta;
+}
+
+bool Viewport::ShouldTopControlsConsumeScroll(
+    const gfx::Vector2dF& scroll_delta) const {
+  if (!host_impl_->top_controls_manager())
+    return false;
+
+  // 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::ScrollOffset Viewport::MaxTotalScrollOffset() const {
+  gfx::ScrollOffset offset;
+
+  offset += inner_scroll_layer_->MaxScrollOffset();
+
+  if (outer_scroll_layer_)
+    offset += outer_scroll_layer_->MaxScrollOffset();
+
+  return offset;
+}
+
+gfx::ScrollOffset Viewport::TotalScrollOffset() const {
+  gfx::ScrollOffset offset;
+
+  offset += inner_scroll_layer_->CurrentScrollOffset();
+
+  if (outer_scroll_layer_)
+    offset += outer_scroll_layer_->CurrentScrollOffset();
+
+  return offset;
+}
+
+
+}  // namespace cc