[blimp] Add SkPicture caching support.

cc/playback/display_item_list.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/display_item_list.h"
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/picture_debug_util.h"
 #include "cc/debug/traced_display_item_list.h"
 #include "cc/debug/traced_value.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/playback/display_item_proto_factory.h"
 #include "cc/playback/drawing_display_item.h"
 #include "cc/playback/largest_display_item.h"
 #include "cc/proto/display_item.pb.h"
 #include "cc/proto/gfx_conversions.h"
+#include "cc/proto/picture_cache.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
-class ImageSerializationProcessor;
+class EnginePictureCache;
 
 namespace {
 
 // We don't perform per-layer solid color analysis when there are too many skia
 // operations.
 const int kOpCountThatIsOkToAnalyze = 10;
 
 bool DisplayItemsTracingEnabled() {
   bool tracing_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.display_items"), &tracing_enabled);
   return tracing_enabled;
 }
 
 const int kDefaultNumDisplayItemsToReserve = 100;
 
+// SkPicture::uniqueID() starts at 1.
+const uint32_t kInvalidEnginePictureID = 0;
+
+uint32_t GetUniqueSkPictureIDOrNothing(const proto::DisplayItem& item_proto) {

[vmpstr, 2016/06/16 22:09:59]

OrNothing is wrong here. It doesn't return nothing.

[nyquist, 2016/06/24 11:11:14]

Done.

+  if (item_proto.type() == proto::DisplayItem::Type_Drawing) {
+    DCHECK(item_proto.has_drawing_item());
+    const proto::DrawingDisplayItem& details = item_proto.drawing_item();
+    DCHECK(details.has_id());
+    const proto::SkPictureID& sk_picture_id = details.id();
+    DCHECK(sk_picture_id.has_unique_id());
+    return sk_picture_id.unique_id();
+  }
+  return kInvalidEnginePictureID;
+}
+
 }  // namespace
 
 scoped_refptr<DisplayItemList> DisplayItemList::Create(
     const gfx::Rect& layer_rect,
     const DisplayItemListSettings& settings) {
   return make_scoped_refptr(new DisplayItemList(
       layer_rect, settings,
       !settings.use_cached_picture || DisplayItemsTracingEnabled()));
 }
 
 scoped_refptr<DisplayItemList> DisplayItemList::CreateFromProto(
     const proto::DisplayItemList& proto,
-    ImageSerializationProcessor* image_serialization_processor) {
+    ClientPictureCache* client_picture_cache) {
   gfx::Rect layer_rect = ProtoToRect(proto.layer_rect());
   scoped_refptr<DisplayItemList> list =
       DisplayItemList::Create(ProtoToRect(proto.layer_rect()),
                               DisplayItemListSettings(proto.settings()));
 
+  std::vector<uint32_t> engine_picture_ids;
   for (int i = 0; i < proto.items_size(); i++) {
     const proto::DisplayItem& item_proto = proto.items(i);
     DisplayItemProtoFactory::AllocateAndConstruct(
-        layer_rect, list.get(), item_proto, image_serialization_processor);
+        layer_rect, list.get(), item_proto, client_picture_cache);
+    engine_picture_ids.push_back(GetUniqueSkPictureIDOrNothing(item_proto));

[vmpstr, 2016/06/16 22:09:59]

So this is meant to have a bunch of 0s in there?

Would this be better written as 

if (item_proto.type() == proto::DisplayItem::Type_Drawing) {
  DCHEKC(item_proto.has_drawing_item());
 
engine_picture_ids.push_back(GetDrawingDisplayItemId(item_proto.drawing_item()));
} else {
  // maybe just skip this case?
  engine_picture_ids.push_back(0);
}

[nyquist, 2016/06/24 11:11:14]

Done.

   }
 
   list->Finalize();
 
+  // Now that the list has been constructed, ensure that the
+  // |engine_picture_ids_| map in order to the same DisplayItems.
+  list->engine_picture_ids_.swap(engine_picture_ids);

[vmpstr, 2016/06/16 22:09:59]

Sorry if I missed this, but why are storing engine_picture_ids_ on display item
list?

[nyquist, 2016/06/24 11:11:14]

From the header where the list of IDs is declared:
"These IDs are intentionally kept separate because they are not needed while
walking the |items_| for raster."

   return list;
 }
 
 DisplayItemList::DisplayItemList(gfx::Rect layer_rect,
                                  const DisplayItemListSettings& settings,
                                  bool retain_individual_display_items)
     : items_(LargestDisplayItemSize(),
              LargestDisplayItemSize() * kDefaultNumDisplayItemsToReserve),
       settings_(settings),
       retain_individual_display_items_(retain_individual_display_items),
       layer_rect_(layer_rect),
       is_suitable_for_gpu_rasterization_(true),
       approximate_op_count_(0),
       picture_memory_usage_(0) {
   if (settings_.use_cached_picture) {
     SkRTreeFactory factory;
     recorder_.reset(new SkPictureRecorder());
 
     SkCanvas* canvas = recorder_->beginRecording(
         layer_rect_.width(), layer_rect_.height(), &factory);
     canvas->translate(-layer_rect_.x(), -layer_rect_.y());
     canvas->clipRect(gfx::RectToSkRect(layer_rect_));
   }
 }
 
 DisplayItemList::~DisplayItemList() {
 }
 
-void DisplayItemList::ToProtobuf(
-    proto::DisplayItemList* proto,
-    ImageSerializationProcessor* image_serialization_processor) {
+void DisplayItemList::ToProtobuf(proto::DisplayItemList* proto) {
   // The flattened SkPicture approach is going away, and the proto
   // doesn't currently support serializing that flattened picture.
   DCHECK(retain_individual_display_items_);
 
   RectToProto(layer_rect_, proto->mutable_layer_rect());
   settings_.ToProtobuf(proto->mutable_settings());
 
   DCHECK_EQ(0, proto->items_size());
   for (const auto& item : items_)
-    item.ToProtobuf(proto->add_items(), image_serialization_processor);
+    item.ToProtobuf(proto->add_items());
+}
+
+void DisplayItemList::MarkForRegistrationEngine(
+    EnginePictureCache* engine_picture_cache) {
+  DCHECK(!marked_);
+  marked_ = true;
+  for (const auto& item : items_)

[vmpstr, 2016/06/16 22:09:59]

What I proposed earlier is to maybe provide this type of iterator publicly

[nyquist, 2016/06/24 11:11:14]

Done.

+    item.MarkForRegistrationEngine(engine_picture_cache);
+}
+
+void DisplayItemList::MarkForUnregistrationEngine(
+    EnginePictureCache* engine_picture_cache) {
+  DCHECK(marked_);
+  marked_ = false;
+  for (const auto& item : items_)
+    item.MarkForUnregistrationEngine(engine_picture_cache);
+}
+
+void DisplayItemList::MarkForRegistrationClient(
+    ClientPictureCache* client_picture_cache) {
+  DCHECK(!marked_);
+  marked_ = true;
+  for (const uint32_t id : engine_picture_ids_) {
+    if (id == kInvalidEnginePictureID)
+      continue;
+    client_picture_cache->MarkPictureForRegistration(id);
+  }
+}
+
+void DisplayItemList::MarkForUnregistrationClient(
+    ClientPictureCache* client_picture_cache) {
+  DCHECK(marked_);
+  marked_ = false;
+  for (const uint32_t id : engine_picture_ids_) {
+    if (id == kInvalidEnginePictureID)
+      continue;
+    client_picture_cache->MarkPictureForUnregistration(id);
+  }
 }
 
 void DisplayItemList::Raster(SkCanvas* canvas,
                              SkPicture::AbortCallback* callback,
                              const gfx::Rect& canvas_target_playback_rect,
                              float contents_scale) const {
   if (!settings_.use_cached_picture) {
     canvas->save();
     canvas->scale(contents_scale, contents_scale);
     for (const auto& item : items_)
@@ skipping 177 matching lines @@
 }
 
 void DisplayItemList::GetDiscardableImagesInRect(
     const gfx::Rect& rect,
     float raster_scale,
     std::vector<DrawImage>* images) {
   image_map_.GetDiscardableImagesInRect(rect, raster_scale, images);
 }
 
 }  // namespace cc