[blimp] Add SkPicture caching support.

cc/trees/layer_tree_host.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 #include <stack>
 #include <string>
 #include <unordered_map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_math.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/base/math_util.h"
+#include "cc/blimp/image_serialization_processor.h"
+#include "cc/blimp/picture_data.h"
+#include "cc/blimp/picture_data_conversions.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/layer_proto_converter.h"
@@ skipping 236 matching lines @@
   InitializeProxy(SingleThreadProxy::Create(this, single_thread_client,
                                             task_runner_provider_.get()),
                   std::move(external_begin_frame_source));
 }
 
 void LayerTreeHost::InitializeRemoteServer(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner) {
   task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
 
+  if (image_serialization_processor_) {
+    engine_picture_cache_ =
+        image_serialization_processor_->CreateEnginePictureCache();
+  }
+
   // The LayerTreeHost on the server never requests the output surface since
   // it is only needed on the client. Since ProxyMain aborts commits if
   // output_surface_lost() is true, always assume we have the output surface
   // on the server.
   output_surface_lost_ = false;
 
   InitializeProxy(ProxyMain::CreateRemote(remote_proto_channel, this,
                                           task_runner_provider_.get()),
                   nullptr);
 }
 
 void LayerTreeHost::InitializeRemoteClient(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   task_runner_provider_ =
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
 
+  if (image_serialization_processor_) {
+    client_picture_cache_ =
+        image_serialization_processor_->CreateClientPictureCache();
+  }
+
   // For the remote mode, the RemoteChannelImpl implements the Proxy, which is
   // owned by the LayerTreeHost. The RemoteChannelImpl pipes requests which need
   // to handled locally, for instance the Output Surface creation to the
   // LayerTreeHost on the client, while the other requests are sent to the
   // RemoteChannelMain on the server which directs them to ProxyMain and the
   // remote server LayerTreeHost.
   InitializeProxy(RemoteChannelImpl::Create(this, remote_proto_channel,
                                             task_runner_provider_.get()),
                   nullptr);
 }
 
 void LayerTreeHost::InitializeForTesting(
     std::unique_ptr<TaskRunnerProvider> task_runner_provider,
     std::unique_ptr<Proxy> proxy_for_testing,
     std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ = std::move(task_runner_provider);
+
+  InitializePictureCacheForTesting();
+
   InitializeProxy(std::move(proxy_for_testing),
                   std::move(external_begin_frame_source));
 }
 
+void LayerTreeHost::InitializePictureCacheForTesting() {
+  if (!image_serialization_processor_)
+    return;
+
+  // Initialize both engine and client cache to ensure serialization tests
+  // with a single LayerTreeHost can work correctly.
+  engine_picture_cache_ =
+      image_serialization_processor_->CreateEnginePictureCache();
+  client_picture_cache_ =
+      image_serialization_processor_->CreateClientPictureCache();
+}
+
 void LayerTreeHost::SetTaskRunnerProviderForTesting(
     std::unique_ptr<TaskRunnerProvider> task_runner_provider) {
   DCHECK(!task_runner_provider_);
   task_runner_provider_ = std::move(task_runner_provider);
 }
 
 void LayerTreeHost::InitializeProxy(
     std::unique_ptr<Proxy> proxy,
     std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
@@ skipping 1157 matching lines @@
 }
 
 bool LayerTreeHost::IsRemoteClient() const {
   return compositor_mode_ == CompositorMode::REMOTE &&
          task_runner_provider_->HasImplThread();
 }
 
 void LayerTreeHost::ToProtobufForCommit(
     proto::LayerTreeHost* proto,
     std::vector<std::unique_ptr<SwapPromise>>* swap_promises) {
+  DCHECK(engine_picture_cache_);
   // Not all fields are serialized, as they are either not needed for a commit,
   // or implementation isn't ready yet.
   // Unsupported items:
   // - animations
   // - UI resources
   // - instrumentation of stats
   // - histograms
   // Skipped items:
   // - SwapPromise as they are mostly used for perf measurements.
   // - The bitmap and GPU memory related items.
@@ skipping 19 matching lines @@
                                                proto->mutable_root_layer());
 
   // layers_that_should_push_properties_ should be serialized before layer
   // properties because it is cleared during the properties serialization.
   for (auto layer : layers_that_should_push_properties_)
     proto->add_layers_that_should_push_properties(layer->id());
 
   LayerProtoConverter::SerializeLayerProperties(this,
                                                 proto->mutable_layer_updates());
 
+  std::vector<PictureData> pictures =
+      engine_picture_cache_->CalculateCacheUpdateAndFlush();
+  proto::PictureDataVectorToSkPicturesProto(pictures,
+                                            proto->mutable_pictures());
+
   proto->set_hud_layer_id(hud_layer_ ? hud_layer_->id() : Layer::INVALID_ID);
   debug_state_.ToProtobuf(proto->mutable_debug_state());
   SizeToProto(device_viewport_size_, proto->mutable_device_viewport_size());
   proto->set_top_controls_shrink_blink_size(top_controls_shrink_blink_size_);
   proto->set_top_controls_height(top_controls_height_);
   proto->set_top_controls_shown_ratio(top_controls_shown_ratio_);
   proto->set_device_scale_factor(device_scale_factor_);
   proto->set_painted_device_scale_factor(painted_device_scale_factor_);
   proto->set_page_scale_factor(page_scale_factor_);
   proto->set_min_page_scale_factor(min_page_scale_factor_);
@@ skipping 36 matching lines @@
 
   proto->set_surface_id_namespace(surface_id_namespace_);
   proto->set_next_surface_sequence(next_surface_sequence_);
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       "cc.remote", "LayerTreeHostProto", source_frame_number_,
       ComputeLayerTreeHostProtoSizeSplitAsValue(proto));
 }
 
 void LayerTreeHost::FromProtobufForCommit(const proto::LayerTreeHost& proto) {
+  DCHECK(client_picture_cache_);
+
   needs_full_tree_sync_ = proto.needs_full_tree_sync();
   needs_meta_info_recomputation_ = proto.needs_meta_info_recomputation();
   source_frame_number_ = proto.source_frame_number();
 
   // Layer hierarchy.
   scoped_refptr<Layer> new_root_layer =
       LayerProtoConverter::DeserializeLayerHierarchy(root_layer_,
                                                      proto.root_layer(), this);
   if (root_layer_ != new_root_layer) {
     root_layer_ = new_root_layer;
   }
 
   for (auto layer_id : proto.layers_that_should_push_properties())
     layers_that_should_push_properties_.insert(layer_id_map_[layer_id]);
 
+  // Ensure ClientPictureCache contains all the necessary SkPictures before
+  // deserializing the properties.
+  proto::SkPictures proto_pictures = proto.pictures();
+  std::vector<PictureData> pictures =
+      SkPicturesProtoToPictureDataVector(proto_pictures);
+  client_picture_cache_->ApplyCacheUpdate(pictures);
+
   LayerProtoConverter::DeserializeLayerProperties(root_layer_.get(),
                                                   proto.layer_updates());
 
+  // The deserialization is finished, so now clear the cache.
+  client_picture_cache_->Flush();
+
   debug_state_.FromProtobuf(proto.debug_state());
   device_viewport_size_ = ProtoToSize(proto.device_viewport_size());
   top_controls_shrink_blink_size_ = proto.top_controls_shrink_blink_size();
   top_controls_height_ = proto.top_controls_height();
   top_controls_shown_ratio_ = proto.top_controls_shown_ratio();
   device_scale_factor_ = proto.device_scale_factor();
   painted_device_scale_factor_ = proto.painted_device_scale_factor();
   page_scale_factor_ = proto.page_scale_factor();
   min_page_scale_factor_ = proto.min_page_scale_factor();
   max_page_scale_factor_ = proto.max_page_scale_factor();
@@ skipping 48 matching lines @@
   int seq_num = property_trees_.sequence_number;
   LayerTreeHostCommon::CallFunctionForEveryLayer(this, [seq_num](Layer* layer) {
     layer->set_property_tree_sequence_number(seq_num);
   });
 
   surface_id_namespace_ = proto.surface_id_namespace();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 }  // namespace cc