Move MaxScrollOffset to property_trees

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 5223 matching lines @@
                                  wheel_scroll_delta));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollViewportRounding) {
   int width = 332;
   int height = 20;
   int scale = 3;
   SetupScrollAndContentsLayers(gfx::Size(width, height));
   host_impl_->active_tree()->InnerViewportContainerLayer()->SetBounds(
       gfx::Size(width * scale - 1, height * scale));
+  RebuildPropertyTrees();
   host_impl_->active_tree()->SetDeviceScaleFactor(scale);
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
 
   LayerImpl* inner_viewport_scroll_layer =
       host_impl_->active_tree()->InnerViewportScrollLayer();
   EXPECT_EQ(gfx::ScrollOffset(0, 0),
             inner_viewport_scroll_layer->MaxScrollOffset());
 }
 
 class TestInputHandlerClient : public InputHandlerClient {
@@ skipping 58 matching lines @@
   float min_page_scale_factor_;
   float max_page_scale_factor_;
 };
 
 TEST_F(LayerTreeHostImplTest, RootLayerScrollOffsetDelegation) {
   TestInputHandlerClient scroll_watcher;
   host_impl_->SetViewportSize(gfx::Size(10, 20));
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   LayerImpl* clip_layer = scroll_layer->parent()->parent();
   clip_layer->SetBounds(gfx::Size(10, 20));
+  RebuildPropertyTrees();
 
   host_impl_->BindToClient(&scroll_watcher);
 
   gfx::Vector2dF initial_scroll_delta(10.f, 10.f);
   scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
   scroll_layer->SetScrollDelta(initial_scroll_delta);
 
   EXPECT_EQ(gfx::ScrollOffset(), scroll_watcher.last_set_scroll_offset());
 
   // Requesting an update results in the current scroll offset being set.
@@ skipping 350 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, OverscrollAlways) {
   InputHandlerScrollResult scroll_result;
   LayerTreeSettings settings = DefaultSettings();
   CreateHostImpl(settings, CreateOutputSurface());
 
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(50, 50));
   LayerImpl* clip_layer = scroll_layer->parent()->parent();
   clip_layer->SetBounds(gfx::Size(50, 50));
+  RebuildPropertyTrees();
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
   DrawFrame();
   EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
 
   // Even though the layer can't scroll the overscroll still happens.
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::WHEEL)
                 .thread);
@@ skipping 2701 matching lines @@
   EXPECT_EQ(-top_controls_height_,
             host_impl_->top_controls_manager()->ControlsTopOffset());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest,
        TopControlsScrollDeltaInOverScroll) {
   // Verifies that the overscroll delta should not have accumulated in
   // the top controls if we do a hide and show without releasing finger.
 
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));

[ajuma, 2016/02/09 22:35:05]

If you build property trees here, you shouldn't need the additional changes to
bounds_delta below (we should be able to handle the changes in
UpdateTopControlsState without another rebuild).

[sunxd, 2016/02/10 16:56:36]

DrawFrame() forces a rebuild of property trees here, so it will still overwrite
the built tree with the one affected by bounds_delta.

[ajuma, 2016/02/10 17:54:58]

How about making a version of DrawFrame that doesn't rebuild? (Ideally, we'd
make DrawFrame itself not always rebuild, and instead make tests that need to
rebuild ask for this explicitly, but doing that is probably beyond the scope of
this CL.)

   host_impl_->top_controls_manager()->UpdateTopControlsState(BOTH, SHOWN,
                                                              false);
+
+  LayerImpl* inner_clip_layer = scroll_layer->scroll_clip_layer();
+  LayerImpl* outer_clip_layer = host_impl_->active_tree()
+                                    ->OuterViewportScrollLayer()
+                                    ->scroll_clip_layer();
+
+  gfx::Vector2dF scroll_bounds_delta = scroll_layer->bounds_delta();
+  scroll_layer->SetBoundsDelta(gfx::Vector2dF());
+
+  gfx::Vector2dF inner_clip_bounds_delta = inner_clip_layer->bounds_delta();
+  inner_clip_layer->SetBoundsDelta(gfx::Vector2dF());
+
+  gfx::Vector2dF outer_clip_bounds_delta = outer_clip_layer->bounds_delta();
+  outer_clip_layer->SetBoundsDelta(gfx::Vector2dF());
+
   DrawFrame();
 
+  scroll_layer->SetBoundsDelta(scroll_bounds_delta);
+  inner_clip_layer->SetBoundsDelta(inner_clip_bounds_delta);
+  outer_clip_layer->SetBoundsDelta(outer_clip_bounds_delta);
+
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::GESTURE)
                 .thread);
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
 
   float offset = 50;
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get())
@@ skipping 1467 matching lines @@
   host_impl_->ActivateSyncTree();
   DrawFrame();
 
   host_impl_->CreatePendingTree();
   host_impl_->active_tree()->SetPageScaleOnActiveTree(2.f);
   LayerImpl* page_scale_layer = host_impl_->active_tree()->PageScaleLayer();
 
   TransformNode* active_tree_node =
       host_impl_->active_tree()->property_trees()->transform_tree.Node(
           page_scale_layer->transform_tree_index());
-  EXPECT_EQ(active_tree_node->data.post_local_scale_factor, 1.f);
+  // SetPageScaleOnActiveTree also updates the factors in property trees.
+  EXPECT_EQ(active_tree_node->data.post_local_scale_factor, 2.f);
   EXPECT_EQ(host_impl_->active_tree()->current_page_scale_factor(), 2.f);
 
   TransformNode* pending_tree_node =
       host_impl_->pending_tree()->property_trees()->transform_tree.Node(
           page_scale_layer->transform_tree_index());
   EXPECT_EQ(pending_tree_node->data.post_local_scale_factor, 1.f);
   EXPECT_EQ(host_impl_->pending_tree()->current_page_scale_factor(), 2.f);
 
   host_impl_->pending_tree()->UpdateDrawProperties(false);
   pending_tree_node =
@@ skipping 81 matching lines @@
     // There should not be any jitter measured till we hit the fixed point hits
     // threshold.
     float expected_jitter =
         (i == pending_tree->kFixedPointHitsThreshold) ? 500 : 0;
     EXPECT_EQ(jitter, expected_jitter);
   }
 }
 
 }  // namespace
 }  // namespace cc