cc: Remove client/engine LayerTreeHostInProcess.

cc/test/remote_compositor_test.cc

Index: cc/test/remote_compositor_test.cc
diff --git a/cc/test/remote_compositor_test.cc b/cc/test/remote_compositor_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..765224990b5dd9f66928db105eb03e84de0ae5a1
--- /dev/null
+++ b/cc/test/remote_compositor_test.cc
@@ -0,0 +1,120 @@
+// 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/test/remote_compositor_test.h"
+
+#include "base/threading/thread_task_runner_handle.h"
+#include "cc/animation/animation_host.h"
+#include "cc/blimp/compositor_proto_state.h"
+#include "cc/blimp/layer_tree_host_remote.h"
+#include "cc/proto/compositor_message.pb.h"
+#include "cc/test/fake_layer_tree_host.h"
+#include "cc/test/fake_proxy.h"
+#include "cc/test/fake_remote_compositor_bridge.h"
+
+namespace cc {
+namespace {
+
+class ProxyForCommitRequest : public FakeProxy {
+ public:
+  bool CommitRequested() const override { return true; }
+};
+
+class RemoteCompositorBridgeForTest : public FakeRemoteCompositorBridge {
+ public:
+  using ProtoFrameCallback = base::Callback<void(
+      std::unique_ptr<CompositorProtoState> compositor_proto_state)>;
+
+  RemoteCompositorBridgeForTest(
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      ProtoFrameCallback proto_frame_callback)
+      : FakeRemoteCompositorBridge(main_task_runner),
+        proto_frame_callback_(proto_frame_callback) {}
+
+  ~RemoteCompositorBridgeForTest() override = default;
+
+  void ProcessCompositorStateUpdate(
+      std::unique_ptr<CompositorProtoState> compositor_proto_state) override {
+    proto_frame_callback_.Run(std::move(compositor_proto_state));
+  }
+
+ private:
+  ProtoFrameCallback proto_frame_callback_;
+};
+
+}  // namespace
+
+RemoteCompositorTest::RemoteCompositorTest() = default;
+
+RemoteCompositorTest::~RemoteCompositorTest() = default;
+
+void RemoteCompositorTest::SetUp() {
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
+      base::ThreadTaskRunnerHandle::Get();
+
+  animation_host_ = AnimationHost::CreateForTesting(ThreadInstance::MAIN);
+
+  // Engine side setup.
+  LayerTreeHostRemote::InitParams params;
+  params.client = &layer_tree_host_client_remote_;
+  params.main_task_runner = main_task_runner;
+  params.mutator_host = animation_host_.get();
+  params.remote_compositor_bridge =
+      base::MakeUnique<RemoteCompositorBridgeForTest>(
+          main_task_runner,
+          base::Bind(&RemoteCompositorTest::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(
+      this, &task_graph_runner_, animation_host_.get(), 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),
+          this);
+}
+
+void RemoteCompositorTest::TearDown() {
+  layer_tree_host_remote_ = nullptr;
+  compositor_state_deserializer_ = nullptr;
+  layer_tree_host_in_process_ = nullptr;
+  animation_host_ = nullptr;
+}
+
+// CompositorStateDeserializer implementation.
+void RemoteCompositorTest::DidUpdateLocalState() {
+  client_state_dirty_ = true;
+}
+
+void RemoteCompositorTest::ApplyViewportDeltas(
+    const gfx::Vector2dF& inner_delta,
+    const gfx::Vector2dF& outer_delta,
+    const gfx::Vector2dF& elastic_overscroll_delta,
+    float page_scale,
+    float top_controls_delta) {
+  compositor_state_deserializer_->ApplyViewportDeltas(
+      inner_delta, outer_delta, elastic_overscroll_delta, page_scale,
+      top_controls_delta);
+}
+
+void RemoteCompositorTest::ProcessCompositorStateUpdate(
+    std::unique_ptr<CompositorProtoState> compositor_proto_state) {
+  compositor_state_deserializer_->DeserializeCompositorUpdate(
+      compositor_proto_state->compositor_message->layer_tree_host());
+}
+
+}  // namespace cc