cc: Make property trees support elastic overscroll

This makes property trees aware of the elastic overscroll
value, which is used for the overscroll rubberbanding
effect on Mac.

BUG=559550
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1494723002

Cr-Commit-Position: refs/heads/master@{#363302}

8 files changed, 216 insertions, 22 deletions

diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc
index 326e507..971888d 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -634,6 +634,8 @@ void BuildPropertyTreesAndComputeVisibleRects(
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
+    const Layer* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ -643,8 +645,9 @@ void BuildPropertyTreesAndComputeVisibleRects(
     LayerList* update_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
-      outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
-      viewport, device_transform, property_trees);
+      outer_viewport_scroll_layer, overscroll_elasticity_layer,
+      elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
+      device_transform, property_trees);
   ComputeVisibleRectsUsingPropertyTrees(root_layer, property_trees,
                                         can_render_to_separate_surface,
                                         update_layer_list);
@@ -655,6 +658,8 @@ void BuildPropertyTreesAndComputeVisibleRects(
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
+    const LayerImpl* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ -664,8 +669,9 @@ void BuildPropertyTreesAndComputeVisibleRects(
     LayerImplList* visible_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
-      outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
-      viewport, device_transform, property_trees);
+      outer_viewport_scroll_layer, overscroll_elasticity_layer,
+      elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
+      device_transform, property_trees);
   ComputeVisibleRectsUsingPropertyTrees(root_layer, property_trees,
                                         can_render_to_separate_surface,
                                         visible_layer_list);
@@ -1077,4 +1083,40 @@ void UpdatePageScaleFactorInPropertyTrees(
       device_transform);
 }
 
+template <typename LayerType>
+static void UpdateElasticOverscrollInPropertyTreesInternal(
+    PropertyTrees* property_trees,
+    const LayerType* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll) {
+  if (!overscroll_elasticity_layer) {
+    DCHECK(elastic_overscroll.IsZero());
+    return;
+  }
+
+  TransformNode* node = property_trees->transform_tree.Node(
+      overscroll_elasticity_layer->transform_tree_index());
+  if (node->data.scroll_offset == gfx::ScrollOffset(elastic_overscroll))
+    return;
+
+  node->data.scroll_offset = gfx::ScrollOffset(elastic_overscroll);
+  node->data.needs_local_transform_update = true;
+  property_trees->transform_tree.set_needs_update(true);
+}
+
+void UpdateElasticOverscrollInPropertyTrees(
+    PropertyTrees* property_trees,
+    const LayerImpl* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll) {
+  UpdateElasticOverscrollInPropertyTreesInternal(
+      property_trees, overscroll_elasticity_layer, elastic_overscroll);
+}
+
+void UpdateElasticOverscrollInPropertyTrees(
+    PropertyTrees* property_trees,
+    const Layer* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll) {
+  UpdateElasticOverscrollInPropertyTreesInternal(
+      property_trees, overscroll_elasticity_layer, elastic_overscroll);
+}
+
 }  // namespace cc
diff --git a/cc/trees/draw_property_utils.h b/cc/trees/draw_property_utils.h
index 5c99458..72d9337 100644
--- a/cc/trees/draw_property_utils.h
+++ b/cc/trees/draw_property_utils.h
@@ -11,6 +11,7 @@
 namespace gfx {
 class Rect;
 class Transform;
+class Vector2dF;
 }  // namespace gfx
 
 namespace cc {
@@ -46,6 +47,8 @@ void CC_EXPORT BuildPropertyTreesAndComputeVisibleRects(
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
+    const Layer* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ -59,6 +62,8 @@ void CC_EXPORT BuildPropertyTreesAndComputeVisibleRects(
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
+    const LayerImpl* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ -123,6 +128,17 @@ UpdatePageScaleFactorInPropertyTrees(PropertyTrees* property_trees,
                                      float page_scale_factor,
                                      float device_scale_factor,
                                      const gfx::Transform device_transform);
+
+void CC_EXPORT UpdateElasticOverscrollInPropertyTrees(
+    PropertyTrees* property_trees,
+    const LayerImpl* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll);
+
+void CC_EXPORT UpdateElasticOverscrollInPropertyTrees(
+    PropertyTrees* property_trees,
+    const Layer* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll);
+
 }  // namespace cc
 
 #endif  // CC_TREES_DRAW_PROPERTY_UTILS_H_
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 338bb36..4152b4d 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -795,10 +795,10 @@ bool LayerTreeHost::DoUpdateLayers(Layer* root_layer) {
                  "LayerTreeHostCommon::ComputeVisibleRectsWithPropertyTrees");
     BuildPropertyTreesAndComputeVisibleRects(
         root_layer, page_scale_layer, inner_viewport_scroll_layer_.get(),
-        outer_viewport_scroll_layer_.get(), page_scale_factor_,
-        device_scale_factor_, gfx::Rect(device_viewport_size_),
-        identity_transform, can_render_to_separate_surface, &property_trees_,
-        &update_layer_list);
+        outer_viewport_scroll_layer_.get(), overscroll_elasticity_layer_.get(),
+        elastic_overscroll_, page_scale_factor_, device_scale_factor_,
+        gfx::Rect(device_viewport_size_), identity_transform,
+        can_render_to_separate_surface, &property_trees_, &update_layer_list);
   }
 
   for (const auto& layer : update_layer_list)
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 172b01e..9ab91f0 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -2766,7 +2766,9 @@ void CalculateDrawPropertiesAndVerify(
         BuildPropertyTreesAndComputeVisibleRects(
             inputs->root_layer, inputs->page_scale_layer,
             inputs->inner_viewport_scroll_layer,
-            inputs->outer_viewport_scroll_layer, inputs->page_scale_factor,
+            inputs->outer_viewport_scroll_layer,
+            inputs->elastic_overscroll_application_layer,
+            inputs->elastic_overscroll, inputs->page_scale_factor,
             inputs->device_scale_factor,
             gfx::Rect(inputs->device_viewport_size), inputs->device_transform,
             inputs->can_render_to_separate_surface, inputs->property_trees,
@@ -2791,14 +2793,18 @@ void CalculateDrawPropertiesAndVerify(
         TRACE_EVENT0(
             TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
             "LayerTreeHostCommon::ComputeJustVisibleRectsWithPropertyTrees");
-        // Since page scale is a SyncedProperty, changes to page scale on the
-        // active tree immediately affect the pending tree, so instead of
-        // trying to update property trees whenever page scale changes, we
-        // update their page scale before using them.
+        // Since page scale and elastic overscroll are SyncedProperties, changes
+        // on the active tree immediately affect the pending tree, so instead of
+        // trying to update property trees whenever these values change, we
+        // update property trees before using them.
         UpdatePageScaleFactorInPropertyTrees(
             inputs->property_trees, inputs->page_scale_layer,
             inputs->page_scale_factor, inputs->device_scale_factor,
             inputs->device_transform);
+        UpdateElasticOverscrollInPropertyTrees(
+            inputs->property_trees,
+            inputs->elastic_overscroll_application_layer,
+            inputs->elastic_overscroll);
         // Similarly, the device viewport and device transform are shared
         // by both trees.
         inputs->property_trees->clip_tree.SetViewportClip(
@@ -2866,9 +2872,12 @@ void LayerTreeHostCommon::CalculateDrawProperties(
                        gfx::Transform(), false);
   PropertyTrees* property_trees =
       inputs->root_layer->layer_tree_host()->property_trees();
+  Layer* overscroll_elasticity_layer = nullptr;
+  gfx::Vector2dF elastic_overscroll;
   BuildPropertyTreesAndComputeVisibleRects(
       inputs->root_layer, inputs->page_scale_layer,
       inputs->inner_viewport_scroll_layer, inputs->outer_viewport_scroll_layer,
+      overscroll_elasticity_layer, elastic_overscroll,
       inputs->page_scale_factor, inputs->device_scale_factor,
       gfx::Rect(inputs->device_viewport_size), inputs->device_transform,
       can_render_to_separate_surface, property_trees, &update_layer_list);
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 152b873..a68cb02 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -13,6 +13,7 @@
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/timing_function.h"
 #include "cc/debug/frame_rate_counter.h"
+#include "cc/input/scroll_elasticity_helper.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/io_surface_layer.h"
 #include "cc/layers/layer_impl.h"
@@ -3846,6 +3847,105 @@ class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestUpdateLayerInEmptyViewport);
 
+class LayerTreeHostTestElasticOverscroll : public LayerTreeHostTest {
+ public:
+  LayerTreeHostTestElasticOverscroll()
+      : scroll_elasticity_helper_(nullptr), num_draws_(0) {}
+
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->enable_elastic_overscroll = true;
+  }
+
+  void SetupTree() override {
+    root_layer_ = Layer::Create(layer_settings());
+    root_layer_->SetBounds(gfx::Size(10, 10));
+
+    scoped_refptr<Layer> inner_viewport_container_layer =
+        Layer::Create(layer_settings());
+    inner_viewport_container_layer->SetBounds(gfx::Size(10, 10));
+    scoped_refptr<Layer> overscroll_elasticity_layer =
+        Layer::Create(layer_settings());
+    scoped_refptr<Layer> page_scale_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> inner_viewport_scroll_layer =
+        Layer::Create(layer_settings());
+    inner_viewport_scroll_layer->SetScrollClipLayerId(
+        inner_viewport_container_layer->id());
+    inner_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
+
+    root_layer_->AddChild(inner_viewport_container_layer);
+    inner_viewport_container_layer->AddChild(overscroll_elasticity_layer);
+    overscroll_elasticity_layer->AddChild(page_scale_layer);
+    page_scale_layer->AddChild(inner_viewport_scroll_layer);
+
+    scoped_refptr<Layer> content_layer =
+        FakePictureLayer::Create(layer_settings(), &client_);
+    content_layer->SetBounds(gfx::Size(10, 10));
+    inner_viewport_scroll_layer->AddChild(content_layer);
+
+    layer_tree_host()->SetRootLayer(root_layer_);
+    layer_tree_host()->RegisterViewportLayers(
+        overscroll_elasticity_layer, page_scale_layer,
+        inner_viewport_scroll_layer, nullptr);
+    LayerTreeHostTest::SetupTree();
+    client_.set_bounds(content_layer->bounds());
+  }
+
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+    if (host_impl->sync_tree()->source_frame_number() == 0) {
+      scroll_elasticity_helper_ = host_impl->CreateScrollElasticityHelper();
+    }
+  }
+
+  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
+    num_draws_++;
+    LayerImpl* content_layer_impl = host_impl->active_tree()
+                                        ->InnerViewportScrollLayer()
+                                        ->children()[0]
+                                        .get();
+    gfx::Transform expected_draw_transform;
+    switch (num_draws_) {
+      case 1:
+        // Initially, there's no overscroll.
+        EXPECT_EQ(expected_draw_transform, content_layer_impl->DrawTransform());
+
+        // Begin overscrolling. This should be reflected in the draw transform
+        // the next time we draw.
+        scroll_elasticity_helper_->SetStretchAmount(gfx::Vector2dF(5.f, 6.f));
+        break;
+      case 2:
+        expected_draw_transform.Translate(-5.0, -6.0);
+        EXPECT_EQ(expected_draw_transform, content_layer_impl->DrawTransform());
+
+        scroll_elasticity_helper_->SetStretchAmount(gfx::Vector2dF(3.f, 2.f));
+        break;
+      case 3:
+        expected_draw_transform.Translate(-3.0, -2.0);
+        EXPECT_EQ(expected_draw_transform, content_layer_impl->DrawTransform());
+
+        scroll_elasticity_helper_->SetStretchAmount(gfx::Vector2dF());
+        break;
+      case 4:
+        EXPECT_EQ(expected_draw_transform, content_layer_impl->DrawTransform());
+        EndTest();
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  void AfterTest() override {}
+
+ private:
+  FakeContentLayerClient client_;
+  scoped_refptr<Layer> root_layer_;
+  ScrollElasticityHelper* scroll_elasticity_helper_;
+  int num_draws_;
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostTestElasticOverscroll);
+
 class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     : public LayerTreeHostTest {
  protected:
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 02583d2..f7fee78 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -789,9 +789,11 @@ void LayerTreeImpl::BuildPropertyTreesForTesting() {
   LayerTreeHostCommon::PreCalculateMetaInformationForTesting(root_layer_.get());
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer_.get(), PageScaleLayer(), InnerViewportScrollLayer(),
-      OuterViewportScrollLayer(), current_page_scale_factor(),
-      device_scale_factor(), gfx::Rect(DrawViewportSize()),
-      layer_tree_host_impl_->DrawTransform(), &property_trees_);
+      OuterViewportScrollLayer(), OverscrollElasticityLayer(),
+      elastic_overscroll()->Current(IsActiveTree()),
+      current_page_scale_factor(), device_scale_factor(),
+      gfx::Rect(DrawViewportSize()), layer_tree_host_impl_->DrawTransform(),
+      &property_trees_);
 }
 
 void LayerTreeImpl::IncrementRenderSurfaceListIdForTesting() {
diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc
index 8bdf7e4..8763b91 100644
--- a/cc/trees/property_tree_builder.cc
+++ b/cc/trees/property_tree_builder.cc
@@ -37,6 +37,8 @@ struct DataForRecursion {
   const LayerType* page_scale_layer;
   const LayerType* inner_viewport_scroll_layer;
   const LayerType* outer_viewport_scroll_layer;
+  const LayerType* overscroll_elasticity_layer;
+  gfx::Vector2dF elastic_overscroll;
   float page_scale_factor;
   bool in_subtree_of_page_scale_layer;
   bool affected_by_inner_viewport_bounds_delta;
@@ -213,6 +215,8 @@ bool AddTransformNodeIfNeeded(
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !layer->parent();
   const bool is_page_scale_layer = layer == data_from_ancestor.page_scale_layer;
+  const bool is_overscroll_elasticity_layer =
+      layer == data_from_ancestor.overscroll_elasticity_layer;
   const bool is_scrollable = layer->scrollable();
   const bool is_fixed = layer->position_constraint().is_fixed_position();
 
@@ -233,7 +237,7 @@ bool AddTransformNodeIfNeeded(
 
   bool requires_node = is_root || is_scrollable || has_significant_transform ||
                        has_any_transform_animation || has_surface || is_fixed ||
-                       is_page_scale_layer;
+                       is_page_scale_layer || is_overscroll_elasticity_layer;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
   DCHECK(is_root || transform_parent);
@@ -365,8 +369,13 @@ bool AddTransformNodeIfNeeded(
                                            layer->transform_origin());
   }
 
-  if (!layer->scroll_parent())
+  if (is_overscroll_elasticity_layer) {
+    DCHECK(!is_scrollable);
+    node->data.scroll_offset =
+        gfx::ScrollOffset(data_from_ancestor.elastic_overscroll);
+  } else if (!layer->scroll_parent()) {
     node->data.scroll_offset = layer->CurrentScrollOffset();
+  }
 
   if (is_fixed) {
     if (data_from_ancestor.affected_by_inner_viewport_bounds_delta) {
@@ -526,6 +535,8 @@ void BuildPropertyTreesTopLevelInternal(
     const LayerType* page_scale_layer,
     const LayerType* inner_viewport_scroll_layer,
     const LayerType* outer_viewport_scroll_layer,
+    const LayerType* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ -535,6 +546,8 @@ void BuildPropertyTreesTopLevelInternal(
     UpdatePageScaleFactorInPropertyTrees(property_trees, page_scale_layer,
                                          page_scale_factor, device_scale_factor,
                                          device_transform);
+    UpdateElasticOverscrollInPropertyTrees(
+        property_trees, overscroll_elasticity_layer, elastic_overscroll);
     property_trees->clip_tree.SetViewportClip(gfx::RectF(viewport));
     property_trees->transform_tree.SetDeviceTransform(device_transform,
                                                       root_layer->position());
@@ -555,6 +568,8 @@ void BuildPropertyTreesTopLevelInternal(
   data_for_recursion.page_scale_layer = page_scale_layer;
   data_for_recursion.inner_viewport_scroll_layer = inner_viewport_scroll_layer;
   data_for_recursion.outer_viewport_scroll_layer = outer_viewport_scroll_layer;
+  data_for_recursion.overscroll_elasticity_layer = overscroll_elasticity_layer;
+  data_for_recursion.elastic_overscroll = elastic_overscroll;
   data_for_recursion.page_scale_factor = page_scale_factor;
   data_for_recursion.in_subtree_of_page_scale_layer = false;
   data_for_recursion.affected_by_inner_viewport_bounds_delta = false;
@@ -593,6 +608,8 @@ void PropertyTreeBuilder::BuildPropertyTrees(
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
+    const Layer* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ -600,8 +617,9 @@ void PropertyTreeBuilder::BuildPropertyTrees(
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
-      outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
-      viewport, device_transform, property_trees);
+      outer_viewport_scroll_layer, overscroll_elasticity_layer,
+      elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
+      device_transform, property_trees);
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(
@@ -609,6 +627,8 @@ void PropertyTreeBuilder::BuildPropertyTrees(
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
+    const LayerImpl* overscroll_elasticity_layer,
+    const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
@@ -616,8 +636,9 @@ void PropertyTreeBuilder::BuildPropertyTrees(
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
-      outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
-      viewport, device_transform, property_trees);
+      outer_viewport_scroll_layer, overscroll_elasticity_layer,
+      elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
+      device_transform, property_trees);
 }
 
 }  // namespace cc
diff --git a/cc/trees/property_tree_builder.h b/cc/trees/property_tree_builder.h
index a6cc52b..23d7e1c 100644
--- a/cc/trees/property_tree_builder.h
+++ b/cc/trees/property_tree_builder.h
@@ -20,6 +20,8 @@ class PropertyTreeBuilder {
                                  const Layer* page_scale_layer,
                                  const Layer* inner_viewport_scroll_layer,
                                  const Layer* outer_viewport_scroll_layer,
+                                 const Layer* overscroll_elasticity_layer,
+                                 const gfx::Vector2dF& elastic_overscroll,
                                  float page_scale_factor,
                                  float device_scale_factor,
                                  const gfx::Rect& viewport,
@@ -29,6 +31,8 @@ class PropertyTreeBuilder {
                                  const LayerImpl* page_scale_layer,
                                  const LayerImpl* inner_viewport_scroll_layer,
                                  const LayerImpl* outer_viewport_scroll_layer,
+                                 const LayerImpl* overscroll_elasticity_layer,
+                                 const gfx::Vector2dF& elastic_overscroll,
                                  float page_scale_factor,
                                  float device_scale_factor,
                                  const gfx::Rect& viewport,