cc/blimp: Set up the framework for state serialization.

cc/blimp/layer_tree_host_remote.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/blimp/layer_tree_host_remote.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/blimp/compositor_proto_state.h"
 #include "cc/blimp/compositor_proto_state_sink.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame_sink.h"
+#include "cc/proto/compositor_message.pb.h"
+#include "cc/proto/layer_tree_host.pb.h"
 #include "cc/trees/layer_tree.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/task_runner_provider.h"
 
 namespace cc {
 namespace {
 // We use a 16ms default frame interval because the rate at which the engine
 // produces main frames doesn't matter.
 base::TimeDelta kDefaultFrameInterval = base::TimeDelta::FromMilliseconds(16);
@@ skipping 344 matching lines @@
   if (max_pipeline_stage_for_current_frame_ < current_pipeline_stage_) {
     // There is nothing to commit so break the swap promises.
     swap_promise_manager_.BreakSwapPromises(
         SwapPromise::DidNotSwapReason::COMMIT_NO_UPDATE);
 
     // For the client, the commit was successful.
     MainFrameComplete();
     return;
   }
 
-  // TODO(khushalsagar): Serialize current state/reset dirty state tracking and
-  // return the result to the state sink instead.
   std::unique_ptr<CompositorProtoState> compositor_state =
       base::MakeUnique<CompositorProtoState>();
+  compositor_state->swap_promises = swap_promise_manager_.TakeSwapPromises();
+  compositor_state->compositor_message =
+      base::MakeUnique<proto::CompositorMessage>();
+  SerializeCurrentState(
+      compositor_state->compositor_message->mutable_layer_tree_host());
   compositor_proto_state_sink_->ProcessCompositorStateUpdate(
       std::move(compositor_state));
 
   MainFrameComplete();
 
   // We can not wait for updates dispatched from the client about the state of
   // drawing or swaps for frames sent. Since these calls can be used by the
   // LayerTreeHostClient to throttle further frame updates, so dispatch them
   // right after the update is processed by the state sink.
   // TODO(khushalsagar): We can not really know what these callbacks end up
@@ skipping 17 matching lines @@
 
   client_->DidCommit();
   client_->DidBeginMainFrame();
 }
 
 void LayerTreeHostRemote::DispatchDrawAndSwapCallbacks() {
   client_->DidCommitAndDrawFrame();
   client_->DidCompleteSwapBuffers();
 }
 
+void LayerTreeHostRemote::SerializeCurrentState(
+    proto::LayerTreeHost* layer_tree_host_proto) {
+  // Serialize the LayerTree.
+  layer_tree_->ToProtobuf(layer_tree_host_proto->mutable_layer_tree(), true);

[ajuma, 2016/09/29 20:55:33]

Instead of passing |true| here, please create a variable with a good name
(perhaps "inputs_only"), set that variable's value to true, and pass that
variable as the argument. That'll make this more readable. An alternative would
be to change the type of the second argument to an enum. (And same comment for
the other callsites of methods with boolean arguments added in this CL.)

[Khushal, 2016/10/04 09:11:50]

Done.

+
+  // Serialize the dirty layers.
+  for (auto* layer : layer_tree_->LayersThatShouldPushProperties())
+    layer->ToLayerPropertiesProto(
+        layer_tree_host_proto->mutable_layer_updates(), true);
+  layer_tree_->LayersThatShouldPushProperties().clear();
+
+  // TODO(khushalsagar): Deal with picture caching.
+}
+
 }  // namespace cc