Rename paint data structures

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/paint/paint_recorder.h"
 #include "cc/playback/clip_display_item.h"
 #include "cc/playback/clip_path_display_item.h"
 #include "cc/playback/compositing_display_item.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/playback/drawing_display_item.h"
 #include "cc/playback/filter_display_item.h"
 #include "cc/playback/float_clip_display_item.h"
 #include "cc/playback/largest_display_item.h"
 #include "cc/playback/transform_display_item.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/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 
 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;
 }
 
-bool GetCanvasClipBounds(SkCanvas* canvas, gfx::Rect* clip_bounds) {
+bool GetCanvasClipBounds(PaintCanvas* canvas, gfx::Rect* clip_bounds) {
   SkRect canvas_clip_bounds;
   if (!canvas->getClipBounds(&canvas_clip_bounds))
     return false;
   *clip_bounds = ToEnclosingRect(gfx::SkRectToRectF(canvas_clip_bounds));
   return true;
 }
 
 const int kDefaultNumDisplayItemsToReserve = 100;
 
 }  // namespace
 
 DisplayItemList::Inputs::Inputs(const DisplayItemListSettings& settings)
     : items(LargestDisplayItemSize(),
             LargestDisplayItemSize() * kDefaultNumDisplayItemsToReserve),
       settings(settings) {}
 
 DisplayItemList::Inputs::~Inputs() {}
 
 scoped_refptr<DisplayItemList> DisplayItemList::Create(
     const DisplayItemListSettings& settings) {
   return make_scoped_refptr(new DisplayItemList(settings));
 }
 
 DisplayItemList::DisplayItemList(const DisplayItemListSettings& settings)
     : inputs_(settings) {}
 
 DisplayItemList::~DisplayItemList() {
 }
 
-void DisplayItemList::Raster(SkCanvas* canvas,
-                             SkPicture::AbortCallback* callback,
+void DisplayItemList::Raster(PaintCanvas* canvas,
+                             PaintRecord::AbortCallback* callback,
                              const gfx::Rect& canvas_target_playback_rect,
                              float contents_scale) const {
   canvas->save();
   if (!canvas_target_playback_rect.IsEmpty()) {
     // canvas_target_playback_rect is specified in device space. We can't
     // use clipRect because canvas CTM will be applied on it. Use clipRegion
     // instead because it ignores canvas CTM.
     SkRegion device_clip;
     device_clip.setRect(gfx::RectToSkIRect(canvas_target_playback_rect));
     canvas->clipRegion(device_clip);
   }
   canvas->scale(contents_scale, contents_scale);
   Raster(canvas, callback);
   canvas->restore();
 }
 
 DISABLE_CFI_PERF
-void DisplayItemList::Raster(SkCanvas* canvas,
-                             SkPicture::AbortCallback* callback) const {
+void DisplayItemList::Raster(PaintCanvas* canvas,
+                             PaintRecord::AbortCallback* callback) const {
   gfx::Rect canvas_playback_rect;
   if (!GetCanvasClipBounds(canvas, &canvas_playback_rect))
     return;
 
   std::vector<size_t> indices;
   rtree_.Search(canvas_playback_rect, &indices);
   for (size_t index : indices) {
     inputs_.items[index].Raster(canvas, callback);
     // We use a callback during solid color analysis on the compositor thread to
     // break out early. Since we're handling a sequence of pictures via rtree
@@ skipping 33 matching lines @@
 }
 
 int DisplayItemList::ApproximateOpCount() const {
   return approximate_op_count_;
 }
 
 size_t DisplayItemList::ApproximateMemoryUsage() const {
   size_t memory_usage = sizeof(*this);
 
   size_t external_memory_usage = 0;
-  // Warning: this double-counts SkPicture data if use_cached_picture is
-  // also true.
   for (const auto& item : inputs_.items) {
     size_t bytes = 0;
     switch (item.type()) {
       case DisplayItem::CLIP:
         bytes = static_cast<const ClipDisplayItem&>(item).ExternalMemoryUsage();
         break;
       case DisplayItem::CLIP_PATH:
         bytes =
             static_cast<const ClipPathDisplayItem&>(item).ExternalMemoryUsage();
         break;
@@ skipping 56 matching lines @@
                            ? inputs_.visual_rects[item_index]
                            : gfx::Rect(),
                        state.get());
       item_index++;
     }
     state->EndArray();  // "items".
   }
   state->SetValue("layer_rect", MathUtil::AsValue(rtree_.GetBounds()));
   state->EndDictionary();  // "params".
 
-  SkPictureRecorder recorder;
+  PaintRecorder recorder;
   gfx::Rect bounds = rtree_.GetBounds();
-  SkCanvas* canvas = recorder.beginRecording(bounds.width(), bounds.height());
+  PaintCanvas* canvas =
+      recorder.beginRecording(bounds.width(), bounds.height());
   canvas->translate(-bounds.x(), -bounds.y());
   canvas->clipRect(gfx::RectToSkRect(bounds));
   Raster(canvas, nullptr, gfx::Rect(), 1.f);
-  sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
+  sk_sp<PaintRecord> picture = recorder.finishRecordingAsPicture();
 
   std::string b64_picture;
   PictureDebugUtil::SerializeAsBase64(picture.get(), &b64_picture);
   state->SetString("skp64", b64_picture);
 
   return std::move(state);
 }
 
 void DisplayItemList::EmitTraceSnapshot() const {
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.display_items") ","
       TRACE_DISABLED_BY_DEFAULT("cc.debug.picture") ","
       TRACE_DISABLED_BY_DEFAULT("devtools.timeline.picture"),
       "cc::DisplayItemList", this,
       TracedDisplayItemList::AsTraceableDisplayItemList(this,
           DisplayItemsTracingEnabled()));
 }
 
 void DisplayItemList::GenerateDiscardableImagesMetadata() {
-  // This should be only called once, and only after CreateAndCacheSkPicture.
+  // This should be only called once.
   DCHECK(image_map_.empty());
 
   gfx::Rect bounds = rtree_.GetBounds();
   DiscardableImageMap::ScopedMetadataGenerator generator(
       &image_map_, gfx::Size(bounds.right(), bounds.bottom()));
   Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
 }
 
 void DisplayItemList::GetDiscardableImagesInRect(
     const gfx::Rect& rect,
     float contents_scale,
     std::vector<DrawImage>* images) {
   image_map_.GetDiscardableImagesInRect(rect, contents_scale, images);
 }
 
 }  // namespace cc