cc/blimp: Set up hooks for scroll/scale sync.

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 "base/bind.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
@@ skipping 32 matching lines @@
       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_++;
   };
 
+  bool SendUpdates(const std::unordered_map<int, gfx::ScrollOffset>& scroll_map,
+                   float page_scale) {
+    return client_->ApplyScrollAndScaleUpdateFromClient(scroll_map, page_scale);
+  }
+
   int num_updates_received() const { return num_updates_received_; }
 
  private:
   int num_updates_received_ = 0;
 };
 
 class MockLayerTreeHostClient : public StubLayerTreeHostClient {
  public:
   MockLayerTreeHostClient() = default;
   ~MockLayerTreeHostClient() override = default;
 
   void set_update_host_callback(base::Closure callback) {
     update_host_callback_ = callback;
   }
 
   void UpdateLayerTreeHost() override {
     update_host_callback_.Run();
     DidUpdateLayerTreeHost();
   }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     DidReceiveBeginMainFrame();
   }
 
   // LayerTreeHostClient implementation.
   MOCK_METHOD0(WillBeginMainFrame, void());
   MOCK_METHOD0(DidBeginMainFrame, void());
   MOCK_METHOD0(DidReceiveBeginMainFrame, void());
   MOCK_METHOD0(DidUpdateLayerTreeHost, void());
+  MOCK_METHOD5(ApplyViewportDeltas,
+               void(const gfx::Vector2dF&,
+                    const gfx::Vector2dF&,
+                    const gfx::Vector2dF&,
+                    float,
+                    float));
   MOCK_METHOD0(WillCommit, void());
   MOCK_METHOD0(DidCommit, void());
   MOCK_METHOD0(DidCommitAndDrawFrame, void());
   MOCK_METHOD0(DidCompleteSwapBuffers, void());
 
  private:
   base::Closure update_host_callback_;
 };
 
 class MockLayer : public Layer {
@@ skipping 248 matching lines @@
   root_layer_->AddChild(child_layer);
   EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, 1);
 
   layer_tree_host_->SetNeedsUpdateLayers();
 
   base::RunLoop().RunUntilIdle();
   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);
+
+  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;
+
+  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;
+
+  EXPECT_CALL(mock_layer_tree_host_client_,
+              ApplyViewportDeltas(inner_viewport_delta, gfx::Vector2dF(),
+                                  gfx::Vector2dF(), page_scale_delta, 1.0f))
+      .Times(1);
+  bool updates_applied =
+      remote_compositor_bridge_->SendUpdates(scroll_updates, new_scale_factor);
+  EXPECT_TRUE(updates_applied);
+  // The host should have pre-emtively applied the changes.
+  EXPECT_EQ(new_scale_factor,
+            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());
+
+  // Destroy a layer and send a scroll update for it. We should be informed that
+  // the update could not be applied successfully.
+  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);
+}
+
 }  // namespace
 }  // namespace cc