Hook ScrollElasticityController to InputHandlerProxy

cc/trees/layer_tree_scroll_elasticity_client.cc

+// Copyright 2014 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/trees/layer_tree_scroll_elasticity_client.h"
+
+#include "cc/layers/layer_impl.h"
+#include "cc/trees/layer_tree_host_impl.h"
+
+namespace cc {
+
+LayerTreeScrollElasticityClient::LayerTreeScrollElasticityClient(
+    LayerTreeHostImpl* layer_tree)
+    : layer_tree_(layer_tree), controller_(NULL), timer_active_(false) {
+}
+
+LayerTreeScrollElasticityClient::~LayerTreeScrollElasticityClient() {
+  if (controller_)
+    controller_->WillShutdown();
+}
+
+void LayerTreeScrollElasticityClient::Animate(base::TimeTicks monotonic_time) {
+  if (!timer_active_)
+    return;
+
+  if (controller_)
+    controller_->Animate(monotonic_time);
+
+  // If the controller has not indicated that it is done animating, request
+  // another frame.
+  if (timer_active_)
+    layer_tree_->SetNeedsAnimate();
+}
+
+void LayerTreeScrollElasticityClient::BindToController(
+    ScrollElasticityController* controller) {
+  DCHECK(!controller_);
+  controller_ = controller;
+}
+
+bool LayerTreeScrollElasticityClient::AllowsHorizontalStretching() {
+  // TODO(ccameron): Get this information from the LayerTreeHostImpl.
+  return true;
+}
+
+bool LayerTreeScrollElasticityClient::AllowsVerticalStretching() {
+  // TODO(ccameron): Get this information from the LayerTreeHostImpl.

[aelias_OOO_until_Jul13, 2014/11/12 22:17:59]

It's difficult to tell whether the way you've set up the classes is the right
factoring without these functions being implemented.  I suspect that you'll end
up duplicating most of these methods in LTHI anyway.  At which point this
isolated class is largely redundant.

Either way, this factoring doesn't really make sense to me.  You currently have
an abstract client class that will only ever have this subclass.  You should
either have the abstract client class with LTHI deriving from it, or you should
have a concrete helper separate from LTHI with no client base class.

I'd suggest you implement these methods and then I can review again; I'm fine
with reviewing a somewhat larger patch, I'm not the kind of reviewer who
necessarily prefers piecemeal ones (in fact I dislike nonfunctional piecemeal
patches because I need to predict the future to know whether something is a good
idea).

[ccameron, 2014/11/13 00:28:37]

This was a reaction against what I perceive to be an excessive surface area of
cc:: being exposed to content:: et al. I'd prefer that we have a cc/public area
where we make a clear delineation of what may be relied on across that border
and what may not.

But, since we're not doing that (at least not yet, and anticipating it is a bad
idea), you're right.

I went with the concrete class as opposed to having LTHI implement a few
interface, because I feel that LTHI is having too much functionality stuffed
into it.
Most of those TODOs should read "this function is actually not needed anymore"
(mostly because the WebKit implementation making over-scroll be a per-layer
option, which complicated that implementation immensely). I'll flesh these out.
There's only one TODO needed at that point (which is the one where we actually
set the transform on a layer that does't exist yet b/c it needs to be added in
WebKit).

It's true that there are a lot of functions here that may be pruned, but much
prefer to make the big changes to ScrollElasticityController in one
self-contained CL (which will remove its attempts to do scrolling, its
dependence on base::Time::Now(), etc).

+  return true;
+}
+
+gfx::Vector2dF LayerTreeScrollElasticityClient::StretchAmount() {
+  return stretch_offset_;
+}
+
+bool LayerTreeScrollElasticityClient::PinnedInDirection(
+    const gfx::Vector2dF& direction) {
+  LayerImpl* layer = layer_tree_->InnerViewportScrollLayer();
+  bool result = false;
+  if (direction.x() < 0)
+    result |= layer->TotalScrollOffset().x() <= 0;
+  if (direction.x() > 0)
+    result |= layer->TotalScrollOffset().x() >= layer->MaxScrollOffset().x();
+  if (direction.y() < 0)
+    result |= layer->TotalScrollOffset().y() <= 0;
+  if (direction.y() > 0)
+    result |= layer->TotalScrollOffset().y() >= layer->MaxScrollOffset().y();
+  return result;
+}
+
+bool LayerTreeScrollElasticityClient::CanScrollHorizontally() {
+  // TODO(ccameron): This information is likely unnecessary, remove it or get
+  // the correct information from LayerTreeHostImpl.
+  return true;
+}
+
+bool LayerTreeScrollElasticityClient::CanScrollVertically() {
+  // TODO(ccameron): This information is likely unnecessary, remove it or get
+  // the correct information from LayerTreeHostImpl.
+  return true;
+}
+
+gfx::Vector2dF LayerTreeScrollElasticityClient::AbsoluteScrollPosition() {
+  // TODO(ccameron): This information is likely unnecessary, remove it or get
+  // the correct information from LayerTreeHostImpl.
+  return stretch_offset_;
+}
+
+void LayerTreeScrollElasticityClient::ImmediateScrollBy(
+    const gfx::Vector2dF& scroll) {
+  // TODO(ccameron): This is no longer necessary because elasticity is now
+  // decoupled from scrolling. Remove this.
+}
+
+void LayerTreeScrollElasticityClient::
+    ImmediateScrollByWithoutContentEdgeConstraints(
+        const gfx::Vector2dF& scroll) {
+  stretch_offset_ += scroll;
+  // TODO(ccameron): Update the transform of the appropriate layer in the
+  // LayerTreeHostImpl, and request that a frame be drawn.
+}
+
+void LayerTreeScrollElasticityClient::StartSnapRubberbandTimer() {
+  if (timer_active_)
+    return;
+  timer_active_ = true;
+  layer_tree_->SetNeedsAnimate();
+}
+
+void LayerTreeScrollElasticityClient::StopSnapRubberbandTimer() {
+  timer_active_ = false;
+}
+
+void LayerTreeScrollElasticityClient::
+    AdjustScrollPositionToBoundsIfNecessary() {
+  // TODO(ccameron): This function is likely unnecessary. Remove it.
+}
+
+}  // namespace cc