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 51 matching lines @@
 
   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();

[Khushal, 2016/10/14 20:12:31]

We should just kill this method now. I'm not sure why I deferred doing this till
the Update call anyway. If a proto comes, we can deserialize right away, during
the BeginMainFrame call itself.

[xingliu, 2016/10/17 16:26:49]

Done.

   }
   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 {
@@ skipping 204 matching lines @@
       layers_scrolled_,
       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) {

[Khushal, 2016/10/14 20:12:31]

Can you add a DCHECK at the beginning of this method for,
DCHECK(layer_tree_host_in_process_->CommitRequested());

The name doesn't say it but that method returns true even if the main frame is
in progress, and we want to make sure that the only time we get proto updates
from the remote host is when the main frame on the InProcessHost is in progress.

-  pending_compositor_proto_state_ = std::move(compositor_proto_state);
+  std::unique_ptr<CompositorProtoState> pending_compositor_proto_state =

[Khushal, 2016/10/14 20:12:31]

Don't really need this temp var.

+      std::move(compositor_proto_state);
+
+  // Deserialize the update from the remote host into client side LTH in
+  // process. This bypasses the network layer.
+  // We can patch test only layer data that are not serialized after the

[Khushal, 2016/10/14 20:12:31]

I would say do it in this patch itself. This was an oversight from my end.
Just walk the entire tree after deserializing, and copy test only values like
|force_render_surface_for_testing_| from Layer here.

[xingliu, 2016/10/17 16:26:49]

Done. Please help to take a look if the patch logic is correct, it looks for
client layer with GetLayerForEngineId and the engine id from the layer update
proto.

+  // deserialization.
+  const proto::LayerTreeHost& layer_tree_host_proto =
+      pending_compositor_proto_state->compositor_message->layer_tree_host();
+  compositor_state_deserializer_->DeserializeCompositorUpdate(
+      layer_tree_host_proto);
 }
 
 void LayerTreeHostRemoteForTesting::UpdateStateOnInProcessHost() {

[Khushal, 2016/10/14 20:12:31]

Remove this method.

[xingliu, 2016/10/17 16:26:49]

Done.

-  // 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);
-
-    pending_compositor_proto_state_ = nullptr;
-
     // 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();

[Khushal, 2016/10/14 20:12:31]

Move this to ProcessRemoteCompositorUpdate. The aim of this was to say that the
remote host should go till the commit pipeline only if someone calls
SetNeedsCommit on the LTH.

Now this might not result in a commit on the InProcessHost because the state
could all still be the same (nothing changed on any layer but we'll still end up
serializing the LayerTree), so the commit will be optimized out. So we
explicitly force a commit to prevent that.

If you're getting a call to ProcessRemoteCompositorUpdate, you know that you
want the InProcessHost to commit.

-  }
 }
 
 }  // namespace cc