Enable some remote LTH tests in layer_tree_host_unittests.

cc/test/layer_tree_host_remote_for_testing.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/layer_tree_host_remote_for_testing.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/blimp/compositor_proto_state.h"
 #include "cc/blimp/compositor_state_deserializer.h"
@@ skipping 50 matching lines @@
   ~LayerTreeHostInProcessClient() override = default;
 
   void WillBeginMainFrame() override {}
   void BeginMainFrame(const BeginFrameArgs& args) override {
     // Send any scroll/scale updates first.
     layer_tree_host_remote_->ApplyUpdatesFromInProcessHost();
     layer_tree_host_remote_->BeginMainFrame();
   }
   void BeginMainFrameNotExpectedSoon() override {}
   void DidBeginMainFrame() override {}
-  void UpdateLayerTreeHost() override {
-    layer_tree_host_remote_->UpdateStateOnInProcessHost();
-  }
+  void UpdateLayerTreeHost() override {}
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float page_scale,
                            float top_controls_delta) override {}
   void RequestNewCompositorFrameSink() override {
     layer_tree_host_remote_->client()->RequestNewCompositorFrameSink();
   }
   void DidInitializeCompositorFrameSink() override {
     layer_tree_host_remote_->client()->DidInitializeCompositorFrameSink();
@@ skipping 199 matching lines @@
       layer_tree_host_in_process_->GetLayerTree()->page_scale_factor());
   layers_scrolled_.clear();
 }
 
 void LayerTreeHostRemoteForTesting::RemoteHostNeedsMainFrame() {
   layer_tree_host_in_process_->SetNeedsAnimate();
 }
 
 void LayerTreeHostRemoteForTesting::ProcessRemoteCompositorUpdate(
     std::unique_ptr<CompositorProtoState> compositor_proto_state) {
-  pending_compositor_proto_state_ = std::move(compositor_proto_state);
-}
+  DCHECK(layer_tree_host_in_process_->CommitRequested());
+  // Deserialize the update from the remote host into client side LTH in
+  // process. This bypasses the network layer.
+  const proto::LayerTreeHost& layer_tree_host_proto =
+      compositor_proto_state->compositor_message->layer_tree_host();
+  compositor_state_deserializer_->DeserializeCompositorUpdate(
+      layer_tree_host_proto);
 
-void LayerTreeHostRemoteForTesting::UpdateStateOnInProcessHost() {
-  // When the InProcess host asks us to update, we de-serialize the update from
-  // the remote host.
-  if (pending_compositor_proto_state_) {
-    const proto::LayerTreeHost& layer_tree_host_proto =
-        pending_compositor_proto_state_->compositor_message->layer_tree_host();
-    compositor_state_deserializer_->DeserializeCompositorUpdate(
-        layer_tree_host_proto);
+  const proto::LayerUpdate& layer_updates =
+      compositor_proto_state->compositor_message->layer_tree_host()
+          .layer_updates();
+  for (int i = 0; i < layer_updates.layers_size(); ++i) {
+    int engine_layer_id = layer_updates.layers(i).id();
+    Layer* engine_layer = GetLayerTree()->LayerById(engine_layer_id);
+    Layer* client_layer =
+        compositor_state_deserializer_->GetLayerForEngineId(engine_layer_id);
 
-    pending_compositor_proto_state_ = nullptr;
+    // Copy test only layer data that are not serialized into network messages.
+    // So in test cases, layers on the client have the same states as their
+    // corresponding layers on the engine.
+    client_layer->SetForceRenderSurfaceForTesting(
+        engine_layer->force_render_surface_for_testing());
+  }
 
-    // The only case where the remote host would give a compositor update is if
-    // they wanted the main frame to go till the commit pipeline stage. So
-    // request one to make sure that the in process main frame also goes till
-    // the commit step.
-    layer_tree_host_in_process_->SetNeedsCommit();
-  }
+  // The only case where the remote host would give a compositor update is if
+  // they wanted the main frame to go till the commit pipeline stage. So
+  // request one to make sure that the in process main frame also goes till
+  // the commit step.
+  layer_tree_host_in_process_->SetNeedsCommit();
 }
 
 }  // namespace cc