[blimp] Add SkPicture caching support.

cc/playback/recording_source.cc

 // Copyright 2014 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/playback/recording_source.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/numerics/safe_math.h"
 #include "cc/base/region.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/raster_source.h"
 #include "cc/proto/gfx_conversions.h"
+#include "cc/proto/picture_cache.h"
 #include "cc/proto/recording_source.pb.h"
 #include "skia/ext/analysis_canvas.h"
 
 namespace {
 
 #ifdef NDEBUG
 const bool kDefaultClearCanvasSetting = false;
 #else
 const bool kDefaultClearCanvasSetting = true;
 #endif
 
 }  // namespace
 
 namespace cc {
-class ImageSerializationProcessor;
 
 RecordingSource::RecordingSource()
     : slow_down_raster_scale_factor_for_debug_(0),
       generate_discardable_images_metadata_(false),
       requires_clear_(false),
       is_solid_color_(false),
       clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
       solid_color_(SK_ColorTRANSPARENT),
       background_color_(SK_ColorTRANSPARENT),
-      painter_reported_memory_usage_(0) {}
+      painter_reported_memory_usage_(0),
+      engine_picture_cache_(nullptr),
+      client_picture_cache_(nullptr) {}
 
-RecordingSource::~RecordingSource() {}
+RecordingSource::~RecordingSource() {
+  Clear();
+}
 
-void RecordingSource::ToProtobuf(
-    proto::RecordingSource* proto,
-    ImageSerializationProcessor* image_serialization_processor) const {
+void RecordingSource::ToProtobuf(proto::RecordingSource* proto) const {
   RectToProto(recorded_viewport_, proto->mutable_recorded_viewport());
   SizeToProto(size_, proto->mutable_size());
   proto->set_slow_down_raster_scale_factor_for_debug(
       slow_down_raster_scale_factor_for_debug_);
   proto->set_generate_discardable_images_metadata(
       generate_discardable_images_metadata_);
   proto->set_requires_clear(requires_clear_);
   proto->set_is_solid_color(is_solid_color_);
   proto->set_clear_canvas_with_debug_color(clear_canvas_with_debug_color_);
   proto->set_solid_color(static_cast<uint64_t>(solid_color_));
   proto->set_background_color(static_cast<uint64_t>(background_color_));
-  if (display_list_) {
-    display_list_->ToProtobuf(proto->mutable_display_list(),
-                              image_serialization_processor);
-  }
+  if (display_list_)
+    display_list_->ToProtobuf(proto->mutable_display_list());
 }
 
-void RecordingSource::FromProtobuf(
-    const proto::RecordingSource& proto,
-    ImageSerializationProcessor* image_serialization_processor) {
+void RecordingSource::FromProtobuf(const proto::RecordingSource& proto) {
+  DCHECK(client_picture_cache_);
   recorded_viewport_ = ProtoToRect(proto.recorded_viewport());
   size_ = ProtoToSize(proto.size());
   slow_down_raster_scale_factor_for_debug_ =
       proto.slow_down_raster_scale_factor_for_debug();
   generate_discardable_images_metadata_ =
       proto.generate_discardable_images_metadata();
   requires_clear_ = proto.requires_clear();
   is_solid_color_ = proto.is_solid_color();
   clear_canvas_with_debug_color_ = proto.clear_canvas_with_debug_color();
   solid_color_ = static_cast<SkColor>(proto.solid_color());
   background_color_ = static_cast<SkColor>(proto.background_color());
 
   // This might not exist if the |display_list_| of the serialized
   // RecordingSource was null, wich can happen if |Clear()| is
-  // called.
+  // called. Whenever the |display_list_| is updated, first unregister the
+  // current content, and then register the new content directly afterwards.
+  MarkForUnregistrationClient();
+  display_list_ = nullptr;
   if (proto.has_display_list()) {
-    display_list_ = DisplayItemList::CreateFromProto(
-        proto.display_list(), image_serialization_processor);
+    display_list_ = DisplayItemList::CreateFromProto(proto.display_list(),
+                                                     client_picture_cache_);
     FinishDisplayItemListUpdate();
-  } else {
-    display_list_ = nullptr;
   }
+  MarkForRegistrationClient();
+}
+
+void RecordingSource::MarkForRegistrationEngine() {
+  if (display_list_ && engine_picture_cache_)
+    display_list_->MarkForRegistrationEngine(engine_picture_cache_);
+}
+
+void RecordingSource::MarkForUnregistrationEngine() {
+  if (display_list_ && engine_picture_cache_)
+    display_list_->MarkForUnregistrationEngine(engine_picture_cache_);
+}
+
+void RecordingSource::MarkForRegistrationClient() {
+  if (display_list_ && client_picture_cache_)
+    display_list_->MarkForRegistrationClient(client_picture_cache_);
+}
+
+void RecordingSource::MarkForUnregistrationClient() {
+  if (display_list_ && client_picture_cache_)
+    display_list_->MarkForUnregistrationClient(client_picture_cache_);
 }
 
 void RecordingSource::UpdateInvalidationForNewViewport(
     const gfx::Rect& old_recorded_viewport,
     const gfx::Rect& new_recorded_viewport,
     Region* invalidation) {
   // Invalidate newly-exposed and no-longer-exposed areas.
   Region newly_exposed_region(new_recorded_viewport);
   newly_exposed_region.Subtract(old_recorded_viewport);
   invalidation->Union(newly_exposed_region);
@@ skipping 11 matching lines @@
     display_list_->GenerateDiscardableImagesMetadata();
 }
 
 void RecordingSource::SetNeedsDisplayRect(const gfx::Rect& layer_rect) {
   if (!layer_rect.IsEmpty()) {
     // Clamp invalidation to the layer bounds.
     invalidation_.Union(gfx::IntersectRects(layer_rect, gfx::Rect(size_)));
   }
 }
 
+void RecordingSource::SetEnginePictureCache(
+    EnginePictureCache* engine_picture_cache) {
+  if (engine_picture_cache_)
+    MarkForUnregistrationEngine();
+  engine_picture_cache_ = engine_picture_cache;
+  if (engine_picture_cache_)
+    MarkForRegistrationEngine();
+}
+
+void RecordingSource::SetClientPictureCache(
+    ClientPictureCache* client_picture_cache) {
+  if (client_picture_cache_)
+    MarkForUnregistrationClient();
+  client_picture_cache_ = client_picture_cache;
+  if (client_picture_cache_)
+    MarkForRegistrationClient();
+}
+
 bool RecordingSource::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     const gfx::Size& layer_size,
     int frame_number,
     RecordingMode recording_mode) {
   bool updated = false;
 
   if (size_ != layer_size)
     size_ = layer_size;
@@ skipping 34 matching lines @@
     case RECORD_WITH_SUBSEQUENCE_CACHING_DISABLED:
       painting_control = ContentLayerClient::SUBSEQUENCE_CACHING_DISABLED;
       break;
     case RECORD_WITH_SK_NULL_CANVAS:
     case RECORDING_MODE_COUNT:
       NOTREACHED();
   }
 
   // TODO(vmpstr): Add a slow_down_recording_scale_factor_for_debug_ to be able
   // to slow down recording.
+  // Whenever the |display_list_| is updated, first unregister the
+  // current content, and then register the new content directly afterwards.
+  MarkForUnregistrationEngine();
   display_list_ = painter->PaintContentsToDisplayList(painting_control);
+  MarkForRegistrationEngine();
+
   painter_reported_memory_usage_ = painter->GetApproximateUnsharedMemoryUsage();
 
   FinishDisplayItemListUpdate();
 
   return true;
 }
 
 gfx::Size RecordingSource::GetSize() const {
   return size_;
 }
@@ skipping 44 matching lines @@
 
   TRACE_EVENT1("cc", "RecordingSource::DetermineIfSolidColor", "opcount",
                display_list_->ApproximateOpCount());
   gfx::Size layer_size = GetSize();
   skia::AnalysisCanvas canvas(layer_size.width(), layer_size.height());
   display_list_->Raster(&canvas, nullptr, gfx::Rect(), 1.f);
   is_solid_color_ = canvas.GetColorIfSolid(&solid_color_);
 }
 
 void RecordingSource::Clear() {
+  // Depending on whether this code is being run on either the engine or client
+  // side, the picture cache needs to be informed that the SkPicture
+  MarkForUnregistrationEngine();
+  MarkForUnregistrationClient();
   recorded_viewport_ = gfx::Rect();
   display_list_ = nullptr;
   painter_reported_memory_usage_ = 0;
   is_solid_color_ = false;
 }
 
 }  // namespace cc