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/atomic_sequence_num.h"
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/blimp/compositor_proto_state.h"
 #include "cc/blimp/remote_compositor_bridge.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 318 matching lines @@
   client_->UpdateLayerTreeHost();
 
   current_pipeline_stage_ = FramePipelineStage::UPDATE_LAYERS;
   LayerList layer_list;
   if (max_pipeline_stage_for_current_frame_ >=
       FramePipelineStage::UPDATE_LAYERS) {
     // Pull updates for all layers from the client.
     // TODO(khushalsagar): Investigate the data impact from updating all the
     // layers. See crbug.com/650885.
     LayerTreeHostCommon::CallFunctionForEveryLayer(
-        layer_tree_.get(),
-        [&layer_list](Layer* layer) { layer_list.push_back(layer); });
+        layer_tree_.get(), [&layer_list](Layer* layer) {
+          layer->SavePaintProperties();
+          layer_list.push_back(layer);
+        });
 
     bool content_is_suitable_for_gpu = false;
     bool layers_updated =
         layer_tree_->UpdateLayers(layer_list, &content_is_suitable_for_gpu);
 
     // If pulling layer updates resulted in any content updates, we need to go
     // till the commit stage.
     if (layers_updated)
       max_pipeline_stage_for_current_frame_ = FramePipelineStage::COMMIT;
   }
 
   current_pipeline_stage_ = FramePipelineStage::COMMIT;
   client_->WillCommit();
 
   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 bridge 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());
   remote_compositor_bridge_->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 bridge.
   // TODO(khushalsagar): We can not really know what these callbacks end up
@@ skipping 13 matching lines @@
 
   client_->DidCommit();
   client_->DidBeginMainFrame();
 }
 
 void LayerTreeHostRemote::DispatchDrawAndSwapCallbacks() {
   client_->DidCommitAndDrawFrame();
   client_->DidCompleteSwapBuffers();
 }
 
+void LayerTreeHostRemote::SerializeCurrentState(
+    proto::LayerTreeHost* layer_tree_host_proto) {
+  // We need to serialize only the inputs received from the embedder.
+  const bool inputs_only = true;
+
+  // Serialize the LayerTree.
+  layer_tree_->ToProtobuf(layer_tree_host_proto->mutable_layer_tree(),
+                          inputs_only);
+
+  // Serialize the dirty layers.
+  for (auto* layer : layer_tree_->LayersThatShouldPushProperties())
+    layer->ToLayerPropertiesProto(
+        layer_tree_host_proto->mutable_layer_updates(), inputs_only);
+  layer_tree_->LayersThatShouldPushProperties().clear();
+
+  // TODO(khushalsagar): Deal with picture caching.
+}
+
 }  // namespace cc