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

cc/blimp/layer_tree_host_remote_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 "cc/blimp/layer_tree_host_remote.h"
 
 #include <memory>
 #include <unordered_set>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
 #include "cc/layers/layer.h"
 #include "cc/output/begin_frame_args.h"
+#include "cc/proto/client_state_update.pb.h"
 #include "cc/proto/compositor_message.pb.h"
+#include "cc/proto/gfx_conversions.h"
 #include "cc/test/fake_image_serialization_processor.h"
 #include "cc/test/fake_remote_compositor_bridge.h"
 #include "cc/test/stub_layer_tree_host_client.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::InSequence;
 using testing::Mock;
 using testing::StrictMock;
 
 #define EXPECT_BEGIN_MAIN_FRAME(client, num)                  \
   EXPECT_CALL(client, WillBeginMainFrame()).Times(num);       \
   EXPECT_CALL(client, DidReceiveBeginMainFrame()).Times(num); \
   EXPECT_CALL(client, DidUpdateLayerTreeHost()).Times(num);   \
   EXPECT_CALL(client, WillCommit()).Times(num);               \
   EXPECT_CALL(client, DidCommit()).Times(num);                \
   EXPECT_CALL(client, DidBeginMainFrame()).Times(num);
 
 #define EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(client, num)    \
   EXPECT_BEGIN_MAIN_FRAME(client, num)                     \
   EXPECT_CALL(client, DidCommitAndDrawFrame()).Times(num); \
   EXPECT_CALL(client, DidReceiveCompositorFrameAck()).Times(num);
 
 namespace cc {
 namespace {
 
+gfx::Vector2dF SerializeScrollUpdate(
+    proto::ClientStateUpdate* client_state_update,
+    Layer* layer,
+    const gfx::ScrollOffset& offset_after_update) {
+  proto::ScrollUpdate* scroll_update =
+      client_state_update->add_scroll_updates();
+  scroll_update->set_layer_id(layer->id());
+  gfx::ScrollOffset scroll_delta = offset_after_update - layer->scroll_offset();
+  gfx::Vector2dF scroll_delta_vector =
+      gfx::ScrollOffsetToVector2dF(scroll_delta);
+  Vector2dFToProto(scroll_delta_vector, scroll_update->mutable_scroll_delta());
+  return scroll_delta_vector;
+}
+
 class UpdateTrackingRemoteCompositorBridge : public FakeRemoteCompositorBridge {
  public:
   UpdateTrackingRemoteCompositorBridge(
       scoped_refptr<base::SingleThreadTaskRunner> compositor_main_task_runner)
       : FakeRemoteCompositorBridge(std::move(compositor_main_task_runner)) {}
 
   ~UpdateTrackingRemoteCompositorBridge() override = default;
 
   void ProcessCompositorStateUpdate(
       std::unique_ptr<CompositorProtoState> compositor_proto_state) override {
     num_updates_received_++;
     compositor_proto_state_ = std::move(compositor_proto_state);
   };
 
-  bool SendUpdates(const std::unordered_map<int, gfx::ScrollOffset>& scroll_map,
-                   float page_scale) {
-    return client_->ApplyScrollAndScaleUpdateFromClient(scroll_map, page_scale);
+  void SendUpdates(const proto::ClientStateUpdate& client_state_update) {
+    client_->ApplyStateUpdateFromClient(client_state_update);
   }
 
   int num_updates_received() const { return num_updates_received_; }
 
   CompositorProtoState* compositor_proto_state() {
     return compositor_proto_state_.get();
   }
 
  private:
   int num_updates_received_ = 0;
@@ skipping 302 matching lines @@
   EXPECT_TRUE(root_layer_->did_update());
   EXPECT_EQ(1, remote_compositor_bridge_->num_updates_received());
 }
 
 TEST_F(LayerTreeHostRemoteTest, ScrollAndScaleSync) {
   scoped_refptr<Layer> child_layer1 = make_scoped_refptr(new MockLayer(false));
   root_layer_->AddChild(child_layer1);
 
   scoped_refptr<Layer> child_layer2 = make_scoped_refptr(new MockLayer(false));
   child_layer1->AddChild(child_layer2);
+  child_layer2->SetScrollOffset(gfx::ScrollOffset(3, 9));
 
   scoped_refptr<Layer> inner_viewport_layer =
       make_scoped_refptr(new MockLayer(false));
   inner_viewport_layer->SetScrollOffset(gfx::ScrollOffset(5, 10));
   root_layer_->AddChild(inner_viewport_layer);
   layer_tree_host_->GetLayerTree()->RegisterViewportLayers(
       nullptr, nullptr, inner_viewport_layer, nullptr);
 
-  // Send scroll and scale updates from client.
-  std::unordered_map<int, gfx::ScrollOffset> scroll_updates;
-  gfx::ScrollOffset child1_offset(4, 5);
-  gfx::ScrollOffset child2_offset(3, 10);
-  gfx::Vector2dF inner_viewport_delta(-2, 5);
-  gfx::ScrollOffset inner_viewport_offset = gfx::ScrollOffsetWithDelta(
-      inner_viewport_layer->scroll_offset(), inner_viewport_delta);
-  scroll_updates[child_layer1->id()] = child1_offset;
-  scroll_updates[child_layer2->id()] = child2_offset;
-  scroll_updates[inner_viewport_layer->id()] = inner_viewport_offset;
+  // First test case.
+  gfx::ScrollOffset expected_child1_offset(4, 5);
+  gfx::ScrollOffset expected_child2_offset(3, 10);
+  gfx::ScrollOffset expected_inner_viewport_offset(-2, 5);
+  float expected_page_scale = 2.0f;
 
-  float page_scale_delta = 0.3f;
-  float current_scale_factor = 0.5f;
-  layer_tree_host_->GetLayerTree()->SetPageScaleFactorAndLimits(
-      current_scale_factor, 0.0f, 1.0f);
-  float new_scale_factor = current_scale_factor * page_scale_delta;
+  proto::ClientStateUpdate client_state_update;
+  SerializeScrollUpdate(&client_state_update, child_layer1.get(),
+                        expected_child1_offset);
+  SerializeScrollUpdate(&client_state_update, child_layer2.get(),
+                        expected_child2_offset);
+  gfx::Vector2dF inner_viewport_delta =
+      SerializeScrollUpdate(&client_state_update, inner_viewport_layer.get(),
+                            expected_inner_viewport_offset);
+  float page_scale_delta =
+      expected_page_scale /
+      layer_tree_host_->GetLayerTree()->page_scale_factor();
+  client_state_update.set_page_scale_delta(page_scale_delta);
 
   EXPECT_CALL(mock_layer_tree_host_client_,
               ApplyViewportDeltas(inner_viewport_delta, gfx::Vector2dF(),
-                                  gfx::Vector2dF(), page_scale_delta, 1.0f))
+                                  gfx::Vector2dF(), page_scale_delta, 0.0f))
       .Times(1);
-  bool updates_applied =
-      remote_compositor_bridge_->SendUpdates(scroll_updates, new_scale_factor);
-  EXPECT_TRUE(updates_applied);
+
+  remote_compositor_bridge_->SendUpdates(client_state_update);
+
   // The host should have pre-emtively applied the changes.
-  EXPECT_EQ(new_scale_factor,
+  EXPECT_EQ(expected_page_scale,
             layer_tree_host_->GetLayerTree()->page_scale_factor());
-  EXPECT_EQ(child1_offset, child_layer1->scroll_offset());
-  EXPECT_EQ(child2_offset, child_layer2->scroll_offset());
-  EXPECT_EQ(inner_viewport_offset, inner_viewport_layer->scroll_offset());
+  EXPECT_EQ(expected_child1_offset, child_layer1->scroll_offset());
+  EXPECT_EQ(expected_child2_offset, child_layer2->scroll_offset());
+  EXPECT_EQ(expected_inner_viewport_offset,
+            inner_viewport_layer->scroll_offset());
 
-  // Destroy a layer and send a scroll update for it. We should be informed that
-  // the update could not be applied successfully.
+  // Remove a layer from the tree and send a scroll update for it.
   child_layer1->RemoveAllChildren();
-  scroll_updates.clear();
-  scroll_updates[child_layer2->id()] = gfx::ScrollOffset(3, 2);
-  updates_applied =
-      remote_compositor_bridge_->SendUpdates(scroll_updates, new_scale_factor);
-  EXPECT_FALSE(updates_applied);
+  proto::ClientStateUpdate client_state_update2;
+  SerializeScrollUpdate(&client_state_update2, child_layer2.get(),
+                        gfx::ScrollOffset(9, 10));
+  remote_compositor_bridge_->SendUpdates(client_state_update2);
 }
 
 TEST_F(LayerTreeHostRemoteTest, IdentifiedLayersToSkipUpdates) {
   EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, 1);
 
   scoped_refptr<MockLayer> non_drawable_layer = new MockLayer(true);
   non_drawable_layer->SetIsDrawable(false);
   non_drawable_layer->SetBounds(gfx::Size(5, 5));
 
   scoped_refptr<MockLayer> empty_bound_layer = new MockLayer(true);
@@ skipping 70 matching lines @@
   DCHECK(compositor_proto_state);
   const proto::LayerUpdate& layer_updates_second_commit =
       compositor_proto_state->compositor_message->layer_tree_host()
           .layer_updates();
   EXPECT_EQ(1, layer_updates_second_commit.layers_size());
   EXPECT_EQ(child_layer->id(), layer_updates_second_commit.layers(0).id());
 }
 
 }  // namespace
 }  // namespace cc