cc: Remove unused proto conversion code.

cc/test/remote_compositor_test.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/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"
@@ skipping 42 matching lines @@
   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 =
+  std::unique_ptr<RemoteCompositorBridgeForTest> bridge_for_test =
       base::MakeUnique<RemoteCompositorBridgeForTest>(
           main_task_runner,
           base::Bind(&RemoteCompositorTest::ProcessCompositorStateUpdate,
                      base::Unretained(this)));
+  fake_remote_compositor_bridge_ = bridge_for_test.get();
+  params.remote_compositor_bridge = std::move(bridge_for_test);
   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() {
+  fake_remote_compositor_bridge_ = nullptr;
   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);
 }
 
+bool RemoteCompositorTest::HasPendingUpdate() const {
+  DCHECK(fake_remote_compositor_bridge_);
+  return fake_remote_compositor_bridge_->has_pending_update();
+}
+
 void RemoteCompositorTest::ProcessCompositorStateUpdate(
     std::unique_ptr<CompositorProtoState> compositor_proto_state) {
   compositor_state_deserializer_->DeserializeCompositorUpdate(
       compositor_proto_state->compositor_message->layer_tree_host());
 }
 
 }  // namespace cc