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

cc/blimp/compositor_state_deserializer_unittest.cc

Index: cc/blimp/compositor_state_deserializer_unittest.cc
diff --git a/cc/blimp/compositor_state_deserializer_unittest.cc b/cc/blimp/compositor_state_deserializer_unittest.cc
index e0637d34b186ca1f3ed80de3ee0b8815f4bbb929..e3879f163ec6384c780ffa5a6cbed3a46dd78474 100644
--- a/cc/blimp/compositor_state_deserializer_unittest.cc
+++ b/cc/blimp/compositor_state_deserializer_unittest.cc
@@ -8,7 +8,6 @@
 #include "cc/animation/animation_host.h"
 #include "cc/blimp/client_picture_cache.h"
 #include "cc/blimp/compositor_proto_state.h"
-#include "cc/blimp/compositor_state_deserializer_client.h"
 #include "cc/blimp/layer_tree_host_remote.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_layer.h"
@@ -23,6 +22,7 @@
 #include "cc/test/remote_client_layer_factory.h"
 #include "cc/test/skia_common.h"
 #include "cc/test/stub_layer_tree_host_client.h"
+#include "cc/test/stub_layer_tree_host_single_thread_client.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -82,7 +82,8 @@ class RemoteCompositorBridgeForTest : public FakeRemoteCompositorBridge {
 
 class CompositorStateDeserializerTest
     : public testing::Test,
-      public CompositorStateDeserializerClient {
+      public CompositorStateDeserializerClient,
+      public FakeLayerTreeHostClient {
  public:
   void SetUp() override {
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
@@ -107,15 +108,13 @@ class CompositorStateDeserializerTest
     layer_tree_host_remote_ = base::MakeUnique<LayerTreeHostRemote>(&params);
 
     // Client side setup.
-    layer_tree_host_in_process_ = FakeLayerTreeHost::Create(
-        &layer_tree_host_client_client_, &task_graph_runner_);
+    layer_tree_host_in_process_ =
+        FakeLayerTreeHost::Create(this, &task_graph_runner_);
     std::unique_ptr<ClientPictureCache> client_picture_cache =
         image_serialization_processor_.CreateClientPictureCache();
     compositor_state_deserializer_ =
         base::MakeUnique<CompositorStateDeserializer>(
             layer_tree_host_in_process_.get(), std::move(client_picture_cache),
-            base::Bind(&CompositorStateDeserializerTest::LayerScrolled,
-                       base::Unretained(this)),
             this);
   }
 
@@ -133,15 +132,17 @@ class CompositorStateDeserializerTest
   }
 
   // CompositorStateDeserializer implementation.
-  bool ShouldRetainClientScroll(int engine_layer_id,
-                                const gfx::ScrollOffset& new_offset) override {
-    return should_retain_client_scroll_;
+  void DidUpdateLocalState() override { client_state_dirty_ = true; }
+
+  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
+                           const gfx::Vector2dF& outer_delta,
+                           const gfx::Vector2dF& elastic_overscroll_delta,
+                           float page_scale,
+                           float top_controls_delta) override {
+    compositor_state_deserializer_->ApplyViewportDeltas(
+        inner_delta, outer_delta, elastic_overscroll_delta, page_scale,
+        top_controls_delta);
   }
-  bool ShouldRetainClientPageScale(float new_page_scale) override {
-    return should_retain_client_scale_;
-  }
-
-  void LayerScrolled(int engine_layer_id) {}
 
   void VerifyTreesAreIdentical() {
     LayerTree* engine_layer_tree = layer_tree_host_remote_->GetLayerTree();
@@ -266,13 +267,12 @@ class CompositorStateDeserializerTest
   // Client setup.
   std::unique_ptr<FakeLayerTreeHost> layer_tree_host_in_process_;
   std::unique_ptr<CompositorStateDeserializer> compositor_state_deserializer_;
-  FakeLayerTreeHostClient layer_tree_host_client_client_;
   TestTaskGraphRunner task_graph_runner_;
+  StubLayerTreeHostSingleThreadClient single_thread_client_;
 
   FakeImageSerializationProcessor image_serialization_processor_;
 
-  bool should_retain_client_scroll_ = false;
-  bool should_retain_client_scale_ = false;
+  bool client_state_dirty_ = false;
 };
 
 TEST_F(CompositorStateDeserializerTest, BasicSync) {
@@ -358,6 +358,8 @@ TEST_F(CompositorStateDeserializerTest, ScrollClipAndMaskLayers) {
 }
 
 TEST_F(CompositorStateDeserializerTest, ReconcileScrollAndScale) {
+  layer_tree_host_in_process_->InitializeSingleThreaded(
+      &single_thread_client_, base::ThreadTaskRunnerHandle::Get());
   scoped_refptr<Layer> root_layer = Layer::Create();
   layer_tree_host_remote_->GetLayerTree()->SetRootLayer(root_layer);
 
@@ -375,32 +377,60 @@ TEST_F(CompositorStateDeserializerTest, ReconcileScrollAndScale) {
   // Synchronize State and verify that the engine values are used.
   base::RunLoop().RunUntilIdle();
   VerifyTreesAreIdentical();
+  Layer* client_scroll_layer =
+      compositor_state_deserializer_->GetLayerForEngineId(scroll_layer->id());
+  EXPECT_EQ(engine_page_scale,
+            layer_tree_host_in_process_->GetLayerTree()->page_scale_factor());
+  EXPECT_EQ(engine_offset, client_scroll_layer->scroll_offset());
+
+  // Now send some updates from the impl thread.
+  ScrollAndScaleSet scroll_and_scale_set;
+
+  gfx::ScrollOffset offset_from_impl_thread(10, 3);
+  LayerTreeHostCommon::ScrollUpdateInfo scroll_update;
+  scroll_update.layer_id = client_scroll_layer->id();
+  gfx::ScrollOffset delta =
+      offset_from_impl_thread - client_scroll_layer->scroll_offset();
+  scroll_update.scroll_delta = gfx::Vector2d(delta.x(), delta.y());

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

gfx::Vector2dF

[Khushal, 2016/10/28 04:11:17]

cc still uses Vector2d for sending updates from impl? And that's the struct I
ended up using for sending the reflected deltas back as well...

[aelias_OOO_until_Jul13, 2016/10/29 02:35:53]

That's a loose end we shouldn't propagate further, please use Vector2dF
everywhere and put in an explicit floor() call somewhere if the truncation is
actually needed.

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

Done.

+  scroll_and_scale_set.scrolls.push_back(scroll_update);
 
+  float page_scale_from_impl_side = 3.2f;
+  scroll_and_scale_set.page_scale_delta =
+      page_scale_from_impl_side /
+      layer_tree_host_in_process_->GetLayerTree()->page_scale_factor();
+
+  layer_tree_host_in_process_->proxy()->SetNeedsCommit();
+  layer_tree_host_in_process_->ApplyScrollAndScale(&scroll_and_scale_set);
+
+  // The values on the client should have been forced to retain the original
+  // engine value.
   EXPECT_EQ(engine_page_scale,
             layer_tree_host_in_process_->GetLayerTree()->page_scale_factor());
-  EXPECT_EQ(engine_offset, compositor_state_deserializer_
-                               ->GetLayerForEngineId(scroll_layer->id())
-                               ->scroll_offset());
+  EXPECT_EQ(engine_offset, client_scroll_layer->scroll_offset());
+
+  // Now pull the deltas from the client onto the engine, this should result
+  // in an aborted commit.
+  proto::ClientStateUpdate client_state_update;
+  compositor_state_deserializer_->PullClientStateUpdate(&client_state_update);
+  layer_tree_host_remote_->ApplyStateUpdateFromClient(client_state_update);
+
+  // Inform the deserializer that the updates were applied on the engine.
+  // This should pre-emptively apply the deltas on the client.
+  compositor_state_deserializer_->DidApplyStateUpdatesOnEngine();
+  EXPECT_EQ(page_scale_from_impl_side,
+            layer_tree_host_in_process_->GetLayerTree()->page_scale_factor());
+  EXPECT_EQ(offset_from_impl_thread, client_scroll_layer->scroll_offset());
 
-  // Now reset the scroll offset and page scale and force-retain the client
-  // values.
-  gfx::ScrollOffset new_engine_offset(2, 2);
+  // Now update the scroll offset on the engine, and ensure that the value is
+  // used on the client.
+  gfx::ScrollOffset new_engine_offset(10, 20);
   scroll_layer->SetScrollOffset(new_engine_offset);
-  float new_engine_page_scale = 0.8f;
-  layer_tree_host_remote_->GetLayerTree()->SetPageScaleFactorAndLimits(
-      new_engine_page_scale, 1.0, 1.0);
-  should_retain_client_scroll_ = true;
-  should_retain_client_scale_ = true;
 
-  // Synchronize State and verify that the client values are retained.
   base::RunLoop().RunUntilIdle();
   VerifyTreesAreIdentical();
-
-  EXPECT_EQ(engine_page_scale,
+  EXPECT_EQ(page_scale_from_impl_side,
             layer_tree_host_in_process_->GetLayerTree()->page_scale_factor());
-  EXPECT_EQ(engine_offset, compositor_state_deserializer_
-                               ->GetLayerForEngineId(scroll_layer->id())
-                               ->scroll_offset());
+  EXPECT_EQ(new_engine_offset, client_scroll_layer->scroll_offset());
 }
 
 TEST_F(CompositorStateDeserializerTest, PropertyTreesAreIdentical) {