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

blimp/client/core/compositor/blimp_compositor_unittest.cc

Index: blimp/client/core/compositor/blimp_compositor_unittest.cc
diff --git a/blimp/client/core/compositor/blimp_compositor_unittest.cc b/blimp/client/core/compositor/blimp_compositor_unittest.cc
index 1425f8702515b6b00f21439b13b43393ebe179e3..9c7d18634bc696457acc94f21c2e4d7e2e7631bc 100644
--- a/blimp/client/core/compositor/blimp_compositor_unittest.cc
+++ b/blimp/client/core/compositor/blimp_compositor_unittest.cc
@@ -8,58 +8,27 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/client/core/compositor/blimp_compositor_dependencies.h"
 #include "blimp/client/core/compositor/blob_image_serialization_processor.h"
+#include "blimp/client/test/compositor/blimp_compositor_with_fake_host.h"
 #include "blimp/client/test/compositor/mock_compositor_dependencies.h"
 #include "cc/layers/layer.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/surfaces/surface_manager.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::_;
-
 namespace blimp {
 namespace client {
+namespace {
 
-class MockBlimpCompositorClient : public BlimpCompositorClient {
- public:
-  MockBlimpCompositorClient() = default;
-  ~MockBlimpCompositorClient() override = default;
-
-  void SendCompositorMessage(
-      const cc::proto::CompositorMessage& message) override {
-    MockableSendCompositorMessage();
-  }
-
-  MOCK_METHOD0(MockableSendCompositorMessage, void());
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockBlimpCompositorClient);
-};
-
-class BlimpCompositorForTesting : public BlimpCompositor {
+class BlimpCompositorTest : public testing::Test, public BlimpCompositorClient {
  public:
-  BlimpCompositorForTesting(
-      BlimpCompositorDependencies* compositor_dependencies,
-      BlimpCompositorClient* client)
-      : BlimpCompositor(compositor_dependencies, client, false) {}
-
-  void SendProto(const cc::proto::CompositorMessage& proto) {
-    SendCompositorProto(proto);
-  }
-
-  cc::LayerTreeHost* host() const { return host_.get(); }
-};
-
-class BlimpCompositorTest : public testing::Test {
- public:
-  BlimpCompositorTest() : loop_(new base::MessageLoop) {}
+  BlimpCompositorTest() = default;
+  ~BlimpCompositorTest() override = default;
 
   void SetUp() override {
     compositor_dependencies_ = base::MakeUnique<BlimpCompositorDependencies>(
         base::MakeUnique<MockCompositorDependencies>());
-
-    compositor_ = base::MakeUnique<BlimpCompositorForTesting>(
-        compositor_dependencies_.get(), &compositor_client_);
+    compositor_ = BlimpCompositorWithFakeHost::Create(
+        compositor_dependencies_.get(), this);
   }
 
   void TearDown() override {
@@ -67,31 +36,91 @@ class BlimpCompositorTest : public testing::Test {
     compositor_dependencies_.reset();
   }
 
-  ~BlimpCompositorTest() override {}
+  void SendFrameUpdate(scoped_refptr<cc::Layer> root_layer) {
+    compositor_->OnCompositorMessageReceived(
+        compositor_->CreateFakeUpdate(root_layer));
+  }
+
+  void SendClientStateUpdateAck() {
+    std::unique_ptr<cc::proto::CompositorMessage> message =
+        base::MakeUnique<cc::proto::CompositorMessage>();
+    message->set_client_state_update_ack(true);
+    compositor_->OnCompositorMessageReceived(std::move(message));
+  }
 
-  std::unique_ptr<base::MessageLoop> loop_;
-  MockBlimpCompositorClient compositor_client_;
+  // BlimpCompositorClient implementation.
+  void SendCompositorMessage(
+      const cc::proto::CompositorMessage& message) override {
+    if (message.has_client_state_update())
+      client_state_updates_++;
+    if (message.has_frame_ack())
+      frame_acks_++;
+  }
+
+  int client_state_updates() const { return client_state_updates_; }
+  int frame_acks() const { return frame_acks_; }
+
+ protected:
+  base::MessageLoop loop_;
   std::unique_ptr<BlimpCompositorDependencies> compositor_dependencies_;
-  std::unique_ptr<BlimpCompositorForTesting> compositor_;
+  std::unique_ptr<BlimpCompositorWithFakeHost> compositor_;
   BlobImageSerializationProcessor blob_image_serialization_processor_;
+
+ private:
+  int client_state_updates_ = 0;
+  int frame_acks_ = 0;
 };
 
-TEST_F(BlimpCompositorTest, ToggleVisibilityWithHost) {
-  compositor_->SetVisible(true);
+TEST_F(BlimpCompositorTest, FrameAck) {
+  // Send a frame and run a local frame update.
+  scoped_refptr<cc::Layer> engine_root_layer = cc::Layer::Create();
+  SendFrameUpdate(engine_root_layer);
+  compositor_->UpdateLayerTreeHost();
+
+  // There should be a local root layer for this engine root layer.
+  cc::Layer* client_root_layer =
+      compositor_->compositor_state_deserializer_for_testing()
+          ->GetLayerForEngineId(engine_root_layer->id());
+  EXPECT_EQ(client_root_layer,
+            compositor_->host()->GetLayerTree()->root_layer());
+
+  // We should have a received an ack for this frame.
+  EXPECT_EQ(1, frame_acks());
+}
+
+TEST_F(BlimpCompositorTest, WaitsForClientAckToFlushState) {
+  EXPECT_EQ(compositor_->host()->reflected_main_frame_state_for_testing(),
+            nullptr);
+
+  // Tell the compositor that the local state was modified and run a frame
+  // update. This should trigger a client state flush.
+  compositor_->DidUpdateLocalState();
+  compositor_->UpdateLayerTreeHost();
+  EXPECT_EQ(1, client_state_updates());
+  // On each update, the reflected main frame state should be sent to the impl
+  // thread.
+  EXPECT_NE(compositor_->host()->reflected_main_frame_state_for_testing(),
+            nullptr);
+
+  // Now do this again while the ack for the previous state update is pending,
+  // the compositor should wait for an ack.
+  compositor_->DidUpdateLocalState();
+  compositor_->UpdateLayerTreeHost();
+  EXPECT_EQ(1, client_state_updates());
+
+  // Send a state ack, this should cause the state to be flushed.
+  SendClientStateUpdateAck();
+  EXPECT_EQ(2, client_state_updates());
+}
 
-  // Check that the visibility is set correctly on the host.
+TEST_F(BlimpCompositorTest, Visible) {
+  compositor_->SetVisible(true);
   EXPECT_TRUE(compositor_->host()->IsVisible());
 
-  // Make the compositor invisible. This should make the |host_| invisible.
   compositor_->SetVisible(false);
   EXPECT_FALSE(compositor_->host()->IsVisible());
 }
 
-TEST_F(BlimpCompositorTest, MessagesHaveCorrectId) {
-  EXPECT_CALL(compositor_client_, MockableSendCompositorMessage()).Times(1);
-
-  compositor_->SendProto(cc::proto::CompositorMessage());
-}
-
+}  // namespace
 }  // namespace client
 }  // namespace blimp