More SkPicture cleanup

src/core/SkPicture.cpp

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPictureFlat.h"
@@ skipping 239 matching lines @@
                     >= kNumAAConcavePathsTol)
             *reason = "Too many anti-aliased concave paths.";
         else
             *reason = "Unknown reason for GPU unsuitability.";
     }
     return ret;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// fRecord OK
-SkPicture::SkPicture(SkScalar width, SkScalar height,
-                     const SkPictureRecord& record,
-                     bool deepCopyOps)
-    : fCullWidth(width)
-    , fCullHeight(height)
-    , fAnalysis() {
-    this->needsNewGenID();
-
-    SkPictInfo info;
-    this->createHeader(&info);
-    fData.reset(SkNEW_ARGS(SkPictureData, (record, info, deepCopyOps)));
-}
-
-// Create an SkPictureData-backed SkPicture from an SkRecord.
-// This for compatibility with serialization code only.  This is not cheap.
-SkPicture* SkPicture::Backport(const SkRecord& src, const SkRect& cullRect) {
-    SkPictureRecord rec(SkISize::Make(cullRect.width(), cullRect.height()), 0/*flags*/);
-    rec.beginRecording();
-        SkRecordDraw(src, &rec, NULL/*bbh*/, NULL/*callback*/);
-    rec.endRecording();
-    return SkNEW_ARGS(SkPicture, (cullRect.width(), cullRect.height(), rec, false/*deepCopyOps*/));
-}
-
-// fRecord OK
 SkPicture::~SkPicture() {
     this->callDeletionListeners();
 }
 
-// fRecord OK
 void SkPicture::EXPERIMENTAL_addAccelData(const SkPicture::AccelData* data) const {
     fAccelData.reset(SkRef(data));
 }
 
-// fRecord OK
 const SkPicture::AccelData* SkPicture::EXPERIMENTAL_getAccelData(
         SkPicture::AccelData::Key key) const {
     if (fAccelData.get() && fAccelData->getKey() == key) {
         return fAccelData.get();
     }
     return NULL;
 }
 
-// fRecord OK
 SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
     static int32_t gNextID = 0;
 
     int32_t id = sk_atomic_inc(&gNextID);
     if (id >= 1 << (8 * sizeof(Domain))) {
         SK_CRASH();
     }
 
     return static_cast<Domain>(id);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// fRecord OK
 void SkPicture::playback(SkCanvas* canvas, SkDrawPictureCallback* callback) const {
     SkASSERT(canvas);
-    SkASSERT(fData.get() || fRecord.get());
 
-    if (fData.get()) {
-        SkPicturePlayback playback(this);
-        playback.draw(canvas, callback);
-    }
-    if (fRecord.get()) {
-        // If the query contains the whole picture, don't bother with the BBH.
-        SkRect clipBounds = { 0, 0, 0, 0 };
-        (void)canvas->getClipBounds(&clipBounds);
-        const bool useBBH = !clipBounds.contains(this->cullRect());
+    // If the query contains the whole picture, don't bother with the BBH.
+    SkRect clipBounds = { 0, 0, 0, 0 };
+    (void)canvas->getClipBounds(&clipBounds);
+    const bool useBBH = !clipBounds.contains(this->cullRect());
 
-        SkRecordDraw(*fRecord, canvas, useBBH ? fBBH.get() : NULL, callback);
-    }
+    SkRecordDraw(*fRecord, canvas, useBBH ? fBBH.get() : NULL, callback);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
 
-// fRecord OK
 bool SkPicture::IsValidPictInfo(const SkPictInfo& info) {
     if (0 != memcmp(info.fMagic, kMagic, sizeof(kMagic))) {
         return false;
     }
 
     if (info.fVersion < MIN_PICTURE_VERSION ||
         info.fVersion > CURRENT_PICTURE_VERSION) {
         return false;
     }
 
     return true;
 }
 
-// fRecord OK
 bool SkPicture::InternalOnly_StreamIsSKP(SkStream* stream, SkPictInfo* pInfo) {
     if (NULL == stream) {
         return false;
     }
 
     // Check magic bytes.
     SkPictInfo info;
     SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
 
     if (!stream->read(&info.fMagic, sizeof(kMagic))) {
@@ skipping 23 matching lines @@
     if (!IsValidPictInfo(info)) {
         return false;
     }
 
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 
-// fRecord OK
 bool SkPicture::InternalOnly_BufferIsSKP(SkReadBuffer* buffer, SkPictInfo* pInfo) {
     // Check magic bytes.
     SkPictInfo info;
     SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
 
     if (!buffer->readByteArray(&info.fMagic, sizeof(kMagic))) {
         return false;
     }
 
     info.fVersion = buffer->readUInt();
@@ skipping 16 matching lines @@
     if (!IsValidPictInfo(info)) {
         return false;
     }
 
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 
-// fRecord OK
-SkPicture::SkPicture(SkPictureData* data, SkScalar width, SkScalar height)
-    : fData(data)
-    , fCullWidth(width)
-    , fCullHeight(height)
-    , fAnalysis() {
-    this->needsNewGenID();
+SkPicture* SkPicture::Forwardport(const SkPictInfo& info, const SkPictureData* data) {

[robertphillips, 2014/11/17 14:11:45]

newline after '{' and ';' ?

[mtklein, 2014/11/17 14:21:44]

Done.

+    if (!data) { return NULL; }
+    SkPicturePlayback playback(data);
+    SkPictureRecorder r;
+    playback.draw(r.beginRecording(SkScalarCeilToInt(info.fCullRect.width()),
+                                   SkScalarCeilToInt(info.fCullRect.height())),
+                  NULL/*no callback*/);
+    return r.endRecording();
 }
 
-SkPicture* SkPicture::Forwardport(const SkPicture& src) {
-    SkAutoTDelete<SkRecord> record(SkNEW(SkRecord));
-    SkRecorder canvas(record.get(), src.cullRect().width(), src.cullRect().height());
-    src.playback(&canvas);
-    return SkNEW_ARGS(SkPicture, (src.cullRect().width(), src.cullRect().height(),
-                                  record.detach(), NULL/*bbh*/));
+SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
+    SkPictInfo info;
+    if (!InternalOnly_StreamIsSKP(stream, &info) || !stream->readBool()) {
+        return NULL;
+    }
+    SkAutoTDelete<SkPictureData> data(SkPictureData::CreateFromStream(stream, info, proc));
+    return Forwardport(info, data);
 }
 
-// fRecord OK
-SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
+SkPicture* SkPicture::CreateFromBuffer(SkReadBuffer& buffer) {
     SkPictInfo info;
-
-    if (!InternalOnly_StreamIsSKP(stream, &info)) {
+    if (!InternalOnly_BufferIsSKP(&buffer, &info) || !buffer.readBool()) {
         return NULL;
     }
-
-    // Check to see if there is a playback to recreate.
-    if (stream->readBool()) {
-        SkPictureData* data = SkPictureData::CreateFromStream(stream, info, proc);
-        if (NULL == data) {
-            return NULL;
-        }
-        const SkPicture src(data, info.fCullRect.width(), info.fCullRect.height());
-        return Forwardport(src);
-    }
-
-    return NULL;
+    SkAutoTDelete<SkPictureData> data(SkPictureData::CreateFromBuffer(buffer, info));
+    return Forwardport(info, data);
 }
 
-// fRecord OK
-SkPicture* SkPicture::CreateFromBuffer(SkReadBuffer& buffer) {
-    SkPictInfo info;
-
-    if (!InternalOnly_BufferIsSKP(&buffer, &info)) {
-        return NULL;
-    }
-
-    // Check to see if there is a playback to recreate.
-    if (buffer.readBool()) {
-        SkPictureData* data = SkPictureData::CreateFromBuffer(buffer, info);
-        if (NULL == data) {
-            return NULL;
-        }
-        const SkPicture src(data, info.fCullRect.width(), info.fCullRect.height());
-        return Forwardport(src);
-    }
-
-    return NULL;
-}
-
-// fRecord OK
 void SkPicture::createHeader(SkPictInfo* info) const {
     // Copy magic bytes at the beginning of the header
     SkASSERT(sizeof(kMagic) == 8);
     SkASSERT(sizeof(kMagic) == sizeof(info->fMagic));
     memcpy(info->fMagic, kMagic, sizeof(kMagic));
 
     // Set picture info after magic bytes in the header
     info->fVersion = CURRENT_PICTURE_VERSION;
     info->fCullRect = this->cullRect();
     info->fFlags = SkPictInfo::kCrossProcess_Flag;
     // TODO: remove this flag, since we're always float (now)
     info->fFlags |= SkPictInfo::kScalarIsFloat_Flag;
 
     if (8 == sizeof(void*)) {
         info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
     }
 }
 
-// fRecord OK
+// This for compatibility with serialization code only.  This is not cheap.
+SkPictureData* SkPicture::Backport(const SkRecord& src, const SkPictInfo& info) {
+    SkPictureRecord rec(SkISize::Make(info.fCullRect.width(), info.fCullRect.height()), 0/*flags*/);
+    rec.beginRecording();
+        SkRecordDraw(src, &rec, NULL/*bbh*/, NULL/*callback*/);
+    rec.endRecording();
+    return SkNEW_ARGS(SkPictureData, (rec, info, false/*deep copy ops?*/));
+}
+
+
 void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
-    const SkPictureData* data = fData.get();
-
-    // If we're a new-format picture, backport to old format for serialization.
-    SkAutoTDelete<SkPicture> oldFormat;
-    if (NULL == data && fRecord.get()) {
-        oldFormat.reset(Backport(*fRecord, this->cullRect()));
-        data = oldFormat->fData.get();
-        SkASSERT(data);
-    }
-
     SkPictInfo info;
     this->createHeader(&info);
-    SkASSERT(sizeof(SkPictInfo) == 32);
+    SkAutoTDelete<SkPictureData> data(Backport(*fRecord, info));
+
     stream->write(&info, sizeof(info));
-
     if (data) {
         stream->writeBool(true);
         data->serialize(stream, encoder);
     } else {
         stream->writeBool(false);
     }
 }
 
-// fRecord OK
 void SkPicture::flatten(SkWriteBuffer& buffer) const {
-    const SkPictureData* data = fData.get();
-
-    // If we're a new-format picture, backport to old format for serialization.
-    SkAutoTDelete<SkPicture> oldFormat;
-    if (NULL == data && fRecord.get()) {
-        oldFormat.reset(Backport(*fRecord, this->cullRect()));
-        data = oldFormat->fData.get();
-        SkASSERT(data);
-    }
-
     SkPictInfo info;
     this->createHeader(&info);
+    SkAutoTDelete<SkPictureData> data(Backport(*fRecord, info));
+
     buffer.writeByteArray(&info.fMagic, sizeof(info.fMagic));
     buffer.writeUInt(info.fVersion);
     buffer.writeRect(info.fCullRect);
     buffer.writeUInt(info.fFlags);
-
     if (data) {
         buffer.writeBool(true);
         data->flatten(buffer);
     } else {
         buffer.writeBool(false);
     }
 }
 
 #if SK_SUPPORT_GPU
-// fRecord OK
-bool SkPicture::suitableForGpuRasterization(GrContext* context, const char **reason) const {
-    if (fRecord.get()) {
-        return fAnalysis.suitableForGpuRasterization(reason, 0);
-    }
-    if (NULL == fData.get()) {
-        if (reason) {
-            *reason = "Missing internal data.";
-        }
-        return false;
-    }
-
-    return fData->suitableForGpuRasterization(context, reason);
+bool SkPicture::suitableForGpuRasterization(GrContext*, const char **reason) const {
+    return fAnalysis.suitableForGpuRasterization(reason, 0);
 }
 #endif
 
-// fRecord OK
-bool SkPicture::hasText() const {
-    if (fRecord.get()) {
-        return fAnalysis.fHasText;
-    }
-    if (fData.get()) {
-        return fData->hasText();
-    }
-    SkFAIL("Unreachable");
-    return false;
-}
+bool SkPicture::hasText()             const { return fAnalysis.fHasText; }
+bool SkPicture::willPlayBackBitmaps() const { return fAnalysis.fWillPlaybackBitmaps; }
+int  SkPicture::approximateOpCount()  const { return fRecord->count(); }
 
-// fRecord OK
-bool SkPicture::willPlayBackBitmaps() const {
-    if (fRecord.get()) {
-        return fAnalysis.fWillPlaybackBitmaps;
-    }
-    if (fData.get()) {
-        return fData->containsBitmaps();
-    }
-    SkFAIL("Unreachable");
-    return false;
-}
+static int32_t gPictureGenerationID = SK_InvalidGenID;  // This will be set at link time.
 
-// fRecord OK
 static int32_t next_picture_generation_id() {
-    static int32_t  gPictureGenerationID = 0;
-    // do a loop in case our global wraps around, as we never want to
-    // return a 0
+    // Loop in case our global wraps around.
     int32_t genID;
     do {
         genID = sk_atomic_inc(&gPictureGenerationID) + 1;
     } while (SK_InvalidGenID == genID);
     return genID;
 }
 
-// fRecord OK
 uint32_t SkPicture::uniqueID() const {
     if (SK_InvalidGenID == fUniqueID) {
         fUniqueID = next_picture_generation_id();
     }
     return fUniqueID;
 }
 
-// fRecord OK
 SkPicture::SkPicture(SkScalar width, SkScalar height, SkRecord* record, SkBBoxHierarchy* bbh)
     : fCullWidth(width)
     , fCullHeight(height)
     , fRecord(record)
     , fBBH(SkSafeRef(bbh))
     , fAnalysis(*fRecord) {
     this->needsNewGenID();
 }
 
 // Note that we are assuming that this entry point will only be called from
 // one thread. Currently the only client of this method is
 // SkGpuDevice::EXPERIMENTAL_optimize which should be only called from a single
 // thread.
 void SkPicture::addDeletionListener(DeletionListener* listener) const {
     SkASSERT(listener);
 
     *fDeletionListeners.append() = SkRef(listener);
 }
 
 void SkPicture::callDeletionListeners() {
     for (int i = 0; i < fDeletionListeners.count(); ++i) {
         fDeletionListeners[i]->onDeletion(this->uniqueID());
     }
 
     fDeletionListeners.unrefAll();
 }
-
-// fRecord OK
-int SkPicture::approximateOpCount() const {
-    SkASSERT(fRecord.get() || fData.get());
-    if (fRecord.get()) {
-        return fRecord->count();
-    }
-    if (fData.get()) {
-        return fData->opCount();
-    }
-    return 0;
-}