[blimp] Add SkPicture caching support.

cc/playback/display_item_list.h

 // 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.
 
 #ifndef CC_PLAYBACK_DISPLAY_ITEM_LIST_H_
 #define CC_PLAYBACK_DISPLAY_ITEM_LIST_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/contiguous_container.h"
 #include "cc/playback/discardable_image_map.h"
 #include "cc/playback/display_item.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/geometry/rect.h"
 
 class SkCanvas;
 class SkPictureRecorder;
 
 namespace cc {
+class ClientPictureCache;
 class DisplayItem;
 class DrawingDisplayItem;
-class ImageSerializationProcessor;
+class EnginePictureCache;
 
 namespace proto {
 class DisplayItemList;
 }
 
 class CC_EXPORT DisplayItemList
     : public base::RefCountedThreadSafe<DisplayItemList> {
  public:
   // Creates a display item list. If picture caching is used, then layer_rect
   // specifies the cull rect of the display item list (the picture will not
   // exceed this rect). If picture caching is not used, then the given rect can
   // be empty.
   // TODO(vmpstr): Maybe this cull rect can be part of the settings instead.
   static scoped_refptr<DisplayItemList> Create(
       const gfx::Rect& layer_rect,
       const DisplayItemListSettings& settings);
 
   // Creates a DisplayItemList from a Protobuf.
   // TODO(dtrainor): Pass in a list of possible DisplayItems to reuse
   // (crbug.com/548434).
   static scoped_refptr<DisplayItemList> CreateFromProto(
       const proto::DisplayItemList& proto,
-      ImageSerializationProcessor* image_serialization_processor);
+      ClientPictureCache* client_picture_cache);
 
   // Creates a Protobuf representing the state of this DisplayItemList.
   // TODO(dtrainor): Don't resend DisplayItems that were already serialized
   // (crbug.com/548434).
-  void ToProtobuf(proto::DisplayItemList* proto,
-                  ImageSerializationProcessor* image_serialization_processor);
+  void ToProtobuf(proto::DisplayItemList* proto);
+
+  // Informs the EnginePictureCache about which SkPictures that are in use.
+  void MarkForRegistrationEngine(EnginePictureCache* engine_picture_cache);

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

I'm really not a fan of having duplicate set of functions because this display
item list can be on both the server and client... 

What I mean to say is that from the design perspective, these functions don't
belong on a display item list.

Is it possible to instead add an iterator to the display item list that iterates
and returns the display items and then use that iterator to mark things in the
engine/client directly?

for (auto& item : display_item_list)
 engine_picture_cache_->MarkForRegistration(item.GetPicture());

with maybe display item having a virtual GetPicture that returns either nullptr
or a picture as appropriate..

WDYt? I'm not suggesting that you do this, but I think we need a better design
instead of this double dispatch-esque approach. This is especially true since
you have to have these functions in pairs depending on what cache you're
registering this in. So if there's another alternative, that's fine as well.

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

Done.

+  void MarkForUnregistrationEngine(EnginePictureCache* engine_picture_cache);
+
+  // Informs the ClientPictureCache about which SkPictures that are in use.
+  void MarkForRegistrationClient(ClientPictureCache* client_picture_cache);
+  void MarkForUnregistrationClient(ClientPictureCache* client_picture_cache);
 
   void Raster(SkCanvas* canvas,
               SkPicture::AbortCallback* callback,
               const gfx::Rect& canvas_target_playback_rect,
               float contents_scale) const;
 
   // This is a fast path for use only if canvas_ is set and
   // retain_individual_display_items_ is false. This method also updates
   // approximate_op_count_.
   void RasterIntoCanvas(const DisplayItem& display_item);
@@ skipping 46 matching lines @@
 
   void ProcessAppendedItem(const DisplayItem* item);
 
   ContiguousContainer<DisplayItem> items_;
   // The visual rects associated with each of the display items in the
   // display item list. There is one rect per display item, and the
   // position in |visual_rects_| matches the position of the item in
   // |items_| . These rects are intentionally kept separate
   // because they are not needed while walking the |items_| for raster.
   std::vector<gfx::Rect> visual_rects_;
+
+  // The engine SkPicture IDs associated with each of the display items in the
+  // display item list. There is one ID per display item, and the
+  // position in |engine_picture_ids_| matches the position of the item in
+  // |items_| . These IDs are intentionally kept separate
+  // because they are not needed while walking the |items_| for raster.
+  std::vector<uint32_t> engine_picture_ids_;
+
   sk_sp<SkPicture> picture_;
 
   std::unique_ptr<SkPictureRecorder> recorder_;
   const DisplayItemListSettings settings_;
   bool retain_individual_display_items_;
 
   gfx::Rect layer_rect_;
   bool is_suitable_for_gpu_rasterization_;
   int approximate_op_count_;
 
   // Memory usage due to the cached SkPicture.
   size_t picture_memory_usage_;
 
   DiscardableImageMap image_map_;
 
+  // |marked_| is true when the last call was for marking SkPictures for
+  // registration, and set to false when they are marked for unregistration.
+  // It is illegal to call the same method twice in a row.
+  bool marked_ = false;
+
   friend class base::RefCountedThreadSafe<DisplayItemList>;
   FRIEND_TEST_ALL_PREFIXES(DisplayItemListTest, ApproximateMemoryUsage);
   DISALLOW_COPY_AND_ASSIGN(DisplayItemList);
 };
 
 }  // namespace cc
 
 #endif  // CC_PLAYBACK_DISPLAY_ITEM_LIST_H_