Rename paint data structures

third_party/WebKit/Source/platform/graphics/PictureSnapshot.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 #include "platform/graphics/ProfilingCanvas.h"
 #include "platform/graphics/ReplayingCanvas.h"
 #include "platform/graphics/skia/ImagePixelLocker.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/image-decoders/ImageFrame.h"
 #include "platform/image-decoders/SegmentReader.h"
 #include "platform/image-encoders/PNGImageEncoder.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkImageDeserializer.h"
-#include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HexNumber.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/TextEncoding.h"
 #include <memory>
 
 namespace blink {
 
-PictureSnapshot::PictureSnapshot(sk_sp<const SkPicture> picture)
+PictureSnapshot::PictureSnapshot(sk_sp<const PaintRecord> picture)
     : m_picture(std::move(picture)) {}
 
 class SkiaImageDecoder final : public SkImageDeserializer {
  public:
   sk_sp<SkImage> makeFromMemory(const void* data,
                                 size_t length,
                                 const SkIRect* subset) override {
     // No need to copy the data; this decodes immediately.
     RefPtr<SegmentReader> segmentReader =
         SegmentReader::createFromSkData(SkData::MakeWithoutCopy(data, length));
     std::unique_ptr<ImageDecoder> imageDecoder = ImageDecoder::create(
         std::move(segmentReader), true, ImageDecoder::AlphaPremultiplied,
         ColorBehavior::ignore());
     if (!imageDecoder)
       return nullptr;
 
     ImageFrame* frame = imageDecoder->frameBufferAtIndex(0);
     return (frame && !imageDecoder->failed())
                ? frame->finalizePixelsAndGetImage()
                : nullptr;
   }
   sk_sp<SkImage> makeFromData(SkData* data, const SkIRect* subset) override {
     return this->makeFromMemory(data->data(), data->size(), subset);
   }
 };
 
 PassRefPtr<PictureSnapshot> PictureSnapshot::load(
     const Vector<RefPtr<TilePictureStream>>& tiles) {
   ASSERT(!tiles.isEmpty());
-  Vector<sk_sp<SkPicture>> pictures;
+  Vector<sk_sp<PaintRecord>> pictures;
   pictures.reserveCapacity(tiles.size());
   FloatRect unionRect;
   for (const auto& tileStream : tiles) {
     SkMemoryStream stream(tileStream->data.begin(), tileStream->data.size());
     SkiaImageDecoder factory;
-    sk_sp<SkPicture> picture = SkPicture::MakeFromStream(&stream, &factory);
+    sk_sp<PaintRecord> picture = PaintRecord::MakeFromStream(&stream, &factory);
     if (!picture)
       return nullptr;
     FloatRect cullRect(picture->cullRect());
     cullRect.moveBy(tileStream->layerOffset);
     unionRect.unite(cullRect);
     pictures.push_back(std::move(picture));
   }
   if (tiles.size() == 1)
     return adoptRef(new PictureSnapshot(std::move(pictures[0])));
-  SkPictureRecorder recorder;
-  SkCanvas* canvas =
+  PaintRecorder recorder;
+  PaintCanvas* canvas =
       recorder.beginRecording(unionRect.width(), unionRect.height(), 0, 0);
   for (size_t i = 0; i < pictures.size(); ++i) {
     canvas->save();
     canvas->translate(tiles[i]->layerOffset.x() - unionRect.x(),
                       tiles[i]->layerOffset.y() - unionRect.y());
     pictures[i]->playback(canvas, 0);
     canvas->restore();
   }
   return adoptRef(new PictureSnapshot(recorder.finishRecordingAsPicture()));
 }
@@ skipping 18 matching lines @@
     ReplayingCanvas canvas(bitmap, fromStep, toStep);
     // Disable LCD text preemptively, because the picture opacity is unknown.
     // The canonical API involves SkSurface props, but since we're not
     // SkSurface-based at this point (see TODO above) we (ab)use saveLayer for
     // this purpose.
     SkAutoCanvasRestore autoRestore(&canvas, false);
     canvas.saveLayer(nullptr, nullptr);
 
     canvas.scale(scale, scale);
     canvas.resetStepCount();
-    m_picture->playback(&canvas, &canvas);
+
+    // TODO(enne): Handle this abort callback in PaintRecord::playback.
+    PaintCanvasPassThrough passthrough(&canvas);
+    m_picture->playback(&passthrough, &canvas);
   }
   std::unique_ptr<Vector<char>> base64Data = WTF::makeUnique<Vector<char>>();
   Vector<char> encodedImage;
 
   sk_sp<SkImage> image = SkImage::MakeFromBitmap(bitmap);
   if (!image)
     return nullptr;
 
   ImagePixelLocker pixelLocker(image, kUnpremul_SkAlphaType,
                                kRGBA_8888_SkColorType);
@@ skipping 37 matching lines @@
     canvas.setTimings(currentTimings);
     m_picture->playback(&canvas);
     now = WTF::monotonicallyIncreasingTime();
   }
   return timings;
 }
 
 std::unique_ptr<JSONArray> PictureSnapshot::snapshotCommandLog() const {
   const SkIRect bounds = m_picture->cullRect().roundOut();
   LoggingCanvas canvas(bounds.width(), bounds.height());
-  m_picture->playback(&canvas);
+  PaintCanvasPassThrough passthrough(&canvas);
+  m_picture->playback(&passthrough);
   return canvas.log();
 }
 
 }  // namespace blink