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

cc/blimp/compositor_state_deserializer_unittest.cc

 // Copyright 2016 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 "compositor_state_deserializer.h"
 
 #include "base/run_loop.h"
 #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"
 #include "cc/layers/solid_color_scrollbar_layer.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/drawing_display_item.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/test/fake_image_serialization_processor.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_client.h"
+#include "cc/test/fake_proxy.h"
 #include "cc/test/fake_remote_compositor_bridge.h"
 #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/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 
 namespace cc {
 namespace {
 
 #define EXPECT_LAYERS_EQ(engine_layer_id, client_layer)                     \
   EXPECT_EQ(                                                                \
       compositor_state_deserializer_->GetLayerForEngineId(engine_layer_id), \
       client_layer);
 
+class ProxyForCommitRequest : public FakeProxy {
+ public:
+  bool CommitRequested() const override { return true; }
+};
+
 class FakeContentLayerClient : public ContentLayerClient {
  public:
   FakeContentLayerClient(scoped_refptr<DisplayItemList> display_list,
                          gfx::Rect recorded_viewport)
       : display_list_(std::move(display_list)),
         recorded_viewport_(recorded_viewport) {}
   ~FakeContentLayerClient() override {}
 
   // ContentLayerClient implementation.
   gfx::Rect PaintableRegion() override { return recorded_viewport_; }
@@ skipping 26 matching lines @@
       std::unique_ptr<CompositorProtoState> compositor_proto_state) override {
     proto_frame_callback_.Run(std::move(compositor_proto_state));
   }
 
  private:
   ProtoFrameCallback proto_frame_callback_;
 };
 
 class CompositorStateDeserializerTest
     : public testing::Test,
-      public CompositorStateDeserializerClient {
+      public CompositorStateDeserializerClient,
+      public FakeLayerTreeHostClient {
  public:
   void SetUp() override {
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
         base::ThreadTaskRunnerHandle::Get();
 
     // Engine side setup.
     LayerTreeHostRemote::InitParams params;
     params.client = &layer_tree_host_client_remote_;
     params.main_task_runner = main_task_runner;
     params.animation_host = AnimationHost::CreateMainInstance();
     params.remote_compositor_bridge =
         base::MakeUnique<RemoteCompositorBridgeForTest>(
             main_task_runner,
             base::Bind(
                 &CompositorStateDeserializerTest::ProcessCompositorStateUpdate,
                 base::Unretained(this)));
     params.engine_picture_cache =
         image_serialization_processor_.CreateEnginePictureCache();
     LayerTreeSettings settings;
     params.settings = &settings;
 
     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_);
+        this, &task_graph_runner_, settings, CompositorMode::THREADED);
+    layer_tree_host_in_process_->InitializeForTesting(
+        TaskRunnerProvider::Create(base::ThreadTaskRunnerHandle::Get(),
+                                   base::ThreadTaskRunnerHandle::Get()),
+        base::MakeUnique<ProxyForCommitRequest>());
     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);
   }
 
   void TearDown() override {
     layer_tree_host_remote_ = nullptr;
     compositor_state_deserializer_ = nullptr;
     layer_tree_host_in_process_ = nullptr;
   }
 
   void ProcessCompositorStateUpdate(
       std::unique_ptr<CompositorProtoState> compositor_proto_state) {
     // Immediately deserialize the state update.
     compositor_state_deserializer_->DeserializeCompositorUpdate(
         compositor_proto_state->compositor_message->layer_tree_host());
   }
 
   // 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();
     LayerTree* client_layer_tree = layer_tree_host_in_process_->GetLayerTree();
 
     if (engine_layer_tree->root_layer()) {
       LayerTreeHostCommon::CallFunctionForEveryLayer(
           engine_layer_tree, [this](Layer* engine_layer) {
             VerifyLayersAreIdentical(
                 engine_layer,
@@ skipping 104 matching lines @@
     }
   }
 
   // Engine setup.
   std::unique_ptr<LayerTreeHostRemote> layer_tree_host_remote_;
   StubLayerTreeHostClient layer_tree_host_client_remote_;
 
   // 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_;
 
   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) {
   // Set up a tree with a single node.
   scoped_refptr<Layer> root_layer = Layer::Create();
   layer_tree_host_remote_->GetLayerTree()->SetRootLayer(root_layer);
 
   // Synchronize State and verify.
   base::RunLoop().RunUntilIdle();
   VerifyTreesAreIdentical();
@@ skipping 82 matching lines @@
   scroll_layer->SetScrollOffset(engine_offset);
 
   // Set page scale.
   float engine_page_scale = 0.5f;
   layer_tree_host_remote_->GetLayerTree()->SetPageScaleFactorAndLimits(
       engine_page_scale, 1.0, 1.0);
 
   // 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, compositor_state_deserializer_
-                               ->GetLayerForEngineId(scroll_layer->id())
-                               ->scroll_offset());
+  EXPECT_EQ(engine_offset, 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 send some updates from the impl thread.
+  ScrollAndScaleSet scroll_and_scale_set;
+
+  gfx::ScrollOffset offset_from_impl_thread(10, 3);
+  gfx::ScrollOffset scroll_delta =
+      offset_from_impl_thread - client_scroll_layer->scroll_offset();
+  LayerTreeHostCommon::ScrollUpdateInfo scroll_update;
+  scroll_update.layer_id = client_scroll_layer->id();
+  scroll_update.scroll_delta = gfx::ScrollOffsetToFlooredVector2d(scroll_delta);
+  scroll_and_scale_set.scrolls.push_back(scroll_update);
+
+  float page_scale_from_impl_side = 3.2f;
+  float page_scale_delta =
+      page_scale_from_impl_side /
+      layer_tree_host_in_process_->GetLayerTree()->page_scale_factor();
+  scroll_and_scale_set.page_scale_delta = page_scale_delta;
+
+  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, 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);
+
+  // Send the reflected main frame state to the client layer tree host.
+  compositor_state_deserializer_->SendUnappliedDeltasToLayerTreeHost();
+  const ReflectedMainFrameState* reflected_state =
+      layer_tree_host_in_process_->reflected_main_frame_state_for_testing();
+  EXPECT_EQ(reflected_state->scrolls.size(), 1u);
+  EXPECT_EQ(reflected_state->scrolls[0].layer_id, client_scroll_layer->id());
+  EXPECT_EQ(reflected_state->scrolls[0].scroll_delta,
+            gfx::ScrollOffsetToVector2dF(scroll_delta));
+  EXPECT_EQ(reflected_state->page_scale_delta, page_scale_delta);
+
+  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 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) {
   // Override the LayerFactory. This is necessary to ensure the layer ids
   // tracked in PropertyTrees on the engine and client are identical.
   compositor_state_deserializer_->SetLayerFactoryForTesting(
       base::MakeUnique<RemoteClientLayerFactory>());
 
   scoped_refptr<Layer> root_layer = Layer::Create();
   root_layer->SetBounds(gfx::Size(10, 10));
@@ skipping 151 matching lines @@
           picture_layer2->id()));
   scoped_refptr<DisplayItemList> client_display_list2 =
       client_picture_layer2->client()->PaintContentsToDisplayList(
           ContentLayerClient::PaintingControlSetting::PAINTING_BEHAVIOR_NORMAL);
   EXPECT_TRUE(AreDisplayListDrawingResultsSame(
       gfx::Rect(layer_size), display_list.get(), client_display_list2.get()));
 }
 
 }  // namespace
 }  // namespace cc