cc/blimp: Add synchronization for scroll/scale state.

cc/trees/layer_tree_host_unittest_scroll.cc

Index: cc/trees/layer_tree_host_unittest_scroll.cc
diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc
index 63ecb57a240b47512263ca0e23bb4f31a86437e5..f19c4ce7d7d0b1a1dfbe62f12304b13d7c16b318 100644
--- a/cc/trees/layer_tree_host_unittest_scroll.cc
+++ b/cc/trees/layer_tree_host_unittest_scroll.cc
@@ -23,6 +23,7 @@
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
+#include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
@@ -2046,5 +2047,156 @@ class LayerTreeHostScrollTestPropertyTreeUpdate
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostScrollTestPropertyTreeUpdate);
 
+class LayerTreeHostScrollTestAppliesReflectedDeltas
+    : public LayerTreeHostScrollTest {
+ public:
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void SetupTree() override {
+    LayerTreeHostScrollTest::SetupTree();
+
+    gfx::Size scroll_layer_bounds(200, 200);
+    layer_tree()->outer_viewport_scroll_layer()->SetBounds(scroll_layer_bounds);
+    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+        initial_offset_);
+    layer_tree()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+        base::Bind(&LayerTreeHostScrollTestAppliesReflectedDeltas::
+                       DidScrollOuterViewport,
+                   base::Unretained(this)));
+
+    layer_tree()->SetPageScaleFactorAndLimits(initial_page_scale_, 0.f, 1.f);
+  }
+
+  void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
+    activation_count_++;
+    LayerImpl* outer_viewport_layer = host_impl->OuterViewportScrollLayer();
+
+    switch (activation_count_) {
+      case 1: {
+        // We have the first tree, so let's scroll the outer viewport layer and
+        // change the page scale.
+        outer_viewport_layer->ScrollBy(outer_viewport_offset_deltas_[0]);
+        last_active_offset_ = outer_viewport_layer->CurrentScrollOffset();
+
+        host_impl->active_tree()->page_scale_factor()->SetCurrent(
+            initial_page_scale_ * page_scale_update_);
+        last_page_scale_ =
+            host_impl->active_tree()->current_page_scale_factor();
+
+        PostSetNeedsCommitToMainThread();
+      } break;
+      case 2:
+        // The scroll offset on the active tree should remain unchanged.
+        EXPECT_EQ(last_active_offset_,
+                  outer_viewport_layer->CurrentScrollOffset());
+        EXPECT_EQ(last_page_scale_,
+                  host_impl->active_tree()->current_page_scale_factor());
+
+        // Scroll again to make sure that only the delta applied in this frame
+        // is reported to the main thread.
+        outer_viewport_layer->ScrollBy(outer_viewport_offset_deltas_[1]);
+        last_active_offset_ = outer_viewport_layer->CurrentScrollOffset();
+
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 3:
+        // The scroll offset on the active tree should remain unchanged.
+        EXPECT_EQ(last_active_offset_,
+                  outer_viewport_layer->CurrentScrollOffset());
+        EXPECT_EQ(last_page_scale_,
+                  host_impl->active_tree()->current_page_scale_factor());
+
+        EndTest();
+        break;
+    }
+  }
+
+  void BeginMainFrame(const BeginFrameArgs& args) override {
+    switch (layer_tree_host()->SourceFrameNumber()) {
+      case 1:
+        // Pretend that we could not apply the deltas this frame and send them
+        // back to the impl thread.
+        layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+            initial_offset_);
+        layer_tree()->SetPageScaleFactorAndLimits(initial_page_scale_, 0.f,
+                                                  1.f);
+
+        SendReflectedMainFrameState(0);
+        break;
+      case 2:
+        // Pretend that the previous delta was handled and now reflect back the
+        // new delta.
+        layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+            gfx::ScrollOffsetWithDelta(initial_offset_,
+                                       outer_viewport_offset_deltas_[0]));
+        layer_tree()->SetPageScaleFactorAndLimits(
+            initial_page_scale_ * page_scale_update_, 0.f, 1.f);
+
+        SendReflectedMainFrameState(1);
+        break;
+    }
+  }
+
+  void DidScrollOuterViewport() {
+    Layer* outer_viewport_layer = layer_tree()->outer_viewport_scroll_layer();
+    gfx::ScrollOffset expected_offset;
+    switch (layer_tree_host()->SourceFrameNumber()) {
+      case 0:
+        NOTREACHED();
+      case 1:
+        expected_offset = gfx::ScrollOffsetWithDelta(
+            initial_offset_, outer_viewport_offset_deltas_[0]);
+        EXPECT_EQ(outer_viewport_layer->scroll_offset(), expected_offset);
+        break;
+      case 2:
+        // Since the first delta was reflected back and not applied on the main
+        // thread, the value here should only include the delta from the second
+        // update.
+        expected_offset = gfx::ScrollOffsetWithDelta(
+            initial_offset_, outer_viewport_offset_deltas_[1]);
+        EXPECT_EQ(outer_viewport_layer->scroll_offset(), expected_offset);
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  void AfterTest() override {}
+
+ private:
+  void SendReflectedMainFrameState(int delta_to_reflect) {
+    std::unique_ptr<ReflectedMainFrameState> reflected_main_frame_state =
+        base::MakeUnique<ReflectedMainFrameState>();
+
+    LayerTreeHostCommon::ScrollUpdateInfo scroll_update;
+    scroll_update.layer_id = layer_tree()->outer_viewport_scroll_layer()->id();
+    scroll_update.scroll_delta =
+        gfx::Vector2d(outer_viewport_offset_deltas_[delta_to_reflect].x(),

[aelias_OOO_until_Jul13, 2016/10/28 03:40:20]

gfx::Vector2dF

[Khushal, 2016/10/31 21:02:01]

Done.

+                      outer_viewport_offset_deltas_[delta_to_reflect].y());
+    reflected_main_frame_state->scrolls.push_back(scroll_update);
+
+    if (delta_to_reflect == 0)
+      reflected_main_frame_state->page_scale_delta = page_scale_update_;
+
+    layer_tree()->SetReflectedMainFrameState(
+        std::move(reflected_main_frame_state));
+  }
+
+  // Accessed on the impl thread.
+  int activation_count_ = 0;
+  gfx::ScrollOffset last_active_offset_;
+  float last_page_scale_ = 0.f;
+
+  const gfx::ScrollOffset initial_offset_ = gfx::ScrollOffset(2, 3);
+  const gfx::Vector2dF outer_viewport_offset_deltas_[2] = {
+      gfx::Vector2dF(10, 3), gfx::Vector2dF(5, 3)};
+
+  const float initial_page_scale_ = 0.5f;
+  const float page_scale_update_ = 0.2f;
+};
+
+// The reflected deltas are supported in threaded mode only.
+MULTI_THREAD_TEST_F(LayerTreeHostScrollTestAppliesReflectedDeltas);
+
 }  // namespace
 }  // namespace cc