cc: Move SyncedScrollOffset to scroll tree

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 2015 matching lines @@
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, max_page_scale);
   }
 
   // Zoom-out clamping
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
-    scroll_layer->PullDeltaForMainThread();
+    scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
 
     float page_scale_delta = 0.1f;
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point());
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, min_page_scale);
 
     EXPECT_TRUE(scroll_info->scrolls.empty());
   }
 
   // Two-finger panning should not happen based on pinch events only
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
-    scroll_layer->PullDeltaForMainThread();
+    scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(20, 20));
 
     float page_scale_delta = 1.f;
     host_impl_->ScrollBegin(BeginState(gfx::Point(10, 10)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(10, 10));
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(20, 20));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
     EXPECT_TRUE(scroll_info->scrolls.empty());
   }
 
   // Two-finger panning should work with interleaved scroll events
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
-    scroll_layer->PullDeltaForMainThread();
+    scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(20, 20));
 
     float page_scale_delta = 1.f;
     host_impl_->ScrollBegin(BeginState(gfx::Point(10, 10)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(10, 10));
     host_impl_->ScrollBy(
         UpdateState(gfx::Point(10, 10), gfx::Vector2d(-10, -10)).get());
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(20, 20));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd(EndState().get());
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
     EXPECT_TRUE(ScrollInfoContains(*scroll_info, scroll_layer->id(),
                                    gfx::Vector2d(-10, -10)));
   }
 
   // Two-finger panning should work when starting fully zoomed out.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(0.5f, 0.5f, 4.f);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
-    scroll_layer->PullDeltaForMainThread();
+    scroll_layer->synced_scroll_offset()->PullDeltaForMainThread();
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 0));
 
     host_impl_->ScrollBegin(BeginState(gfx::Point(0, 0)).get(),
                             InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(2.f, gfx::Point(0, 0));
     host_impl_->PinchGestureUpdate(1.f, gfx::Point(0, 0));
 
     // Needed so layer transform includes page scale.
     DrawFrame();
@@ skipping 8067 matching lines @@
                                    ->OuterViewportScrollLayer()
                                    ->children()[0]
                                    .get();
     // The scroll done on the active tree is undone on the pending tree.
     gfx::Transform translate;
     translate.Translate(0, accumulated_scroll);
     content_layer->SetTransform(translate);
 
     LayerTreeImpl* pending_tree = host_impl_->pending_tree();
     pending_tree->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
+    LayerImpl* last_scrolled_layer = pending_tree->LayerById(
+        host_impl_->active_tree()->LastScrolledLayerId());
+    gfx::ScrollOffset pending_base =
+        last_scrolled_layer->synced_scroll_offset()->PendingBase();
     pending_tree->property_trees()->needs_rebuild = true;
     pending_tree->BuildPropertyTreesForTesting();
+    last_scrolled_layer->synced_scroll_offset()->PushFromMainThread(
+        pending_base);

[ajuma, 2016/03/03 18:05:06]

The way this logic worked before relied on the pending and active layers sharing
the same persistent SyncedProperty instance. But now we get a new SyncedProperty
instance each time we build property trees. Do you also need to make sure that
the active_base_ and active_delta_ (not just the pending_base_) get restored to
the previous value? Also, please add a comment explaining why the scroll offset
needs to be updated this way.

[sunxd, 2016/03/03 18:50:13]

I think we don't need to. ScrollTree only clear itself when built from main
thread, when building from impl thread, it calls synced_scroll_offset to do the
updates where synced_scroll_offset can fetch the existing offset.

+
     pending_tree->set_needs_update_draw_properties();
     pending_tree->UpdateDrawProperties(false);
-    LayerImpl* last_scrolled_layer = pending_tree->LayerById(
-        host_impl_->active_tree()->LastScrolledLayerId());
     float jitter =
         LayerTreeHostCommon::CalculateFrameJitter(last_scrolled_layer);
     // 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