Revert of move annotations to canvas virtual

src/core/SkPaint.cpp

 /*
  * Copyright 2006 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 "SkPaint.h"
+#include "SkAnnotation.h"
 #include "SkAutoKern.h"
 #include "SkChecksum.h"
 #include "SkColorFilter.h"
 #include "SkData.h"
 #include "SkDraw.h"
 #include "SkFontDescriptor.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkMaskGamma.h"
@@ skipping 27 matching lines @@
 SkPaint::SkPaint() {
     fTypeface    = nullptr;
     fPathEffect  = nullptr;
     fShader      = nullptr;
     fXfermode    = nullptr;
     fMaskFilter  = nullptr;
     fColorFilter = nullptr;
     fRasterizer  = nullptr;
     fLooper      = nullptr;
     fImageFilter = nullptr;
+    fAnnotation  = nullptr;
 
     fTextSize   = SkPaintDefaults_TextSize;
     fTextScaleX = SK_Scalar1;
     fTextSkewX  = 0;
     fColor      = SK_ColorBLACK;
     fWidth      = 0;
     fMiterLimit = SkPaintDefaults_MiterLimit;
 
     // Zero all bitfields, then set some non-zero defaults.
     fBitfieldsUInt           = 0;
@@ skipping 12 matching lines @@
 
     REF_COPY(fTypeface);
     REF_COPY(fPathEffect);
     REF_COPY(fShader);
     REF_COPY(fXfermode);
     REF_COPY(fMaskFilter);
     REF_COPY(fColorFilter);
     REF_COPY(fRasterizer);
     REF_COPY(fLooper);
     REF_COPY(fImageFilter);
+    REF_COPY(fAnnotation);
 
     COPY(fTextSize);
     COPY(fTextScaleX);
     COPY(fTextSkewX);
     COPY(fColor);
     COPY(fWidth);
     COPY(fMiterLimit);
     COPY(fBitfields);
 
 #undef COPY
 #undef REF_COPY
 }
 
 SkPaint::SkPaint(SkPaint&& src) {
 #define MOVE(field) field = std::move(src.field)
 #define REF_MOVE(field) field = src.field; src.field = nullptr
 
     REF_MOVE(fTypeface);
     REF_MOVE(fPathEffect);
     REF_MOVE(fShader);
     REF_MOVE(fXfermode);
     REF_MOVE(fMaskFilter);
     REF_MOVE(fColorFilter);
     REF_MOVE(fRasterizer);
     REF_MOVE(fLooper);
     REF_MOVE(fImageFilter);
+    REF_MOVE(fAnnotation);
 
     MOVE(fTextSize);
     MOVE(fTextScaleX);
     MOVE(fTextSkewX);
     MOVE(fColor);
     MOVE(fWidth);
     MOVE(fMiterLimit);
     MOVE(fBitfields);
 
 #undef MOVE
 #undef REF_MOVE
 }
 
 SkPaint::~SkPaint() {
     SkSafeUnref(fTypeface);
     SkSafeUnref(fPathEffect);
     SkSafeUnref(fShader);
     SkSafeUnref(fXfermode);
     SkSafeUnref(fMaskFilter);
     SkSafeUnref(fColorFilter);
     SkSafeUnref(fRasterizer);
     SkSafeUnref(fLooper);
     SkSafeUnref(fImageFilter);
+    SkSafeUnref(fAnnotation);
 }
 
 SkPaint& SkPaint::operator=(const SkPaint& src) {
     if (this == &src) {
         return *this;
     }
 
 #define COPY(field) field = src.field
 #define REF_COPY(field) SkSafeUnref(field); field = SkSafeRef(src.field)
 
     REF_COPY(fTypeface);
     REF_COPY(fPathEffect);
     REF_COPY(fShader);
     REF_COPY(fXfermode);
     REF_COPY(fMaskFilter);
     REF_COPY(fColorFilter);
     REF_COPY(fRasterizer);
     REF_COPY(fLooper);
     REF_COPY(fImageFilter);
+    REF_COPY(fAnnotation);
 
     COPY(fTextSize);
     COPY(fTextScaleX);
     COPY(fTextSkewX);
     COPY(fColor);
     COPY(fWidth);
     COPY(fMiterLimit);
     COPY(fBitfields);
 
     return *this;
@@ skipping 12 matching lines @@
 
     REF_MOVE(fTypeface);
     REF_MOVE(fPathEffect);
     REF_MOVE(fShader);
     REF_MOVE(fXfermode);
     REF_MOVE(fMaskFilter);
     REF_MOVE(fColorFilter);
     REF_MOVE(fRasterizer);
     REF_MOVE(fLooper);
     REF_MOVE(fImageFilter);
+    REF_MOVE(fAnnotation);
 
     MOVE(fTextSize);
     MOVE(fTextScaleX);
     MOVE(fTextSkewX);
     MOVE(fColor);
     MOVE(fWidth);
     MOVE(fMiterLimit);
     MOVE(fBitfields);
 
     return *this;
 
 #undef MOVE
 #undef REF_MOVE
 }
 
 bool operator==(const SkPaint& a, const SkPaint& b) {
 #define EQUAL(field) (a.field == b.field)
     return EQUAL(fTypeface)
         && EQUAL(fPathEffect)
         && EQUAL(fShader)
         && EQUAL(fXfermode)
         && EQUAL(fMaskFilter)
         && EQUAL(fColorFilter)
         && EQUAL(fRasterizer)
         && EQUAL(fLooper)
         && EQUAL(fImageFilter)
+        && EQUAL(fAnnotation)
         && EQUAL(fTextSize)
         && EQUAL(fTextScaleX)
         && EQUAL(fTextSkewX)
         && EQUAL(fColor)
         && EQUAL(fWidth)
         && EQUAL(fMiterLimit)
         && EQUAL(fBitfieldsUInt)
         ;
 #undef EQUAL
 }
@@ skipping 181 matching lines @@
 SkDrawLooper* SkPaint::setLooper(SkDrawLooper* looper) {
     SkRefCnt_SafeAssign(fLooper, looper);
     return looper;
 }
 
 SkImageFilter* SkPaint::setImageFilter(SkImageFilter* imageFilter) {
     SkRefCnt_SafeAssign(fImageFilter, imageFilter);
     return imageFilter;
 }
 
+SkAnnotation* SkPaint::setAnnotation(SkAnnotation* annotation) {
+    SkRefCnt_SafeAssign(fAnnotation, annotation);
+    return annotation;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkScalar mag2(SkScalar x, SkScalar y) {
     return x * x + y * y;
 }
 
 static bool tooBig(const SkMatrix& m, SkScalar ma2max) {
     return  mag2(m[SkMatrix::kMScaleX], m[SkMatrix::kMSkewY]) > ma2max
             ||
             mag2(m[SkMatrix::kMSkewX], m[SkMatrix::kMScaleY]) > ma2max;
@@ skipping 1452 matching lines @@
     if (this->getTypeface()) {
         flatFlags |= kHasTypeface_FlatFlag;
     }
     if (asint(this->getPathEffect()) |
         asint(this->getShader()) |
         asint(this->getXfermode()) |
         asint(this->getMaskFilter()) |
         asint(this->getColorFilter()) |
         asint(this->getRasterizer()) |
         asint(this->getLooper()) |
+        asint(this->getAnnotation()) |
         asint(this->getImageFilter())) {
         flatFlags |= kHasEffects_FlatFlag;
     }
 
     SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
     uint32_t* ptr = buffer.reserve(kPODPaintSize);
 
     ptr = write_scalar(ptr, this->getTextSize());
     ptr = write_scalar(ptr, this->getTextScaleX());
     ptr = write_scalar(ptr, this->getTextSkewX());
@@ skipping 13 matching lines @@
     }
     if (flatFlags & kHasEffects_FlatFlag) {
         buffer.writeFlattenable(this->getPathEffect());
         buffer.writeFlattenable(this->getShader());
         buffer.writeFlattenable(this->getXfermode());
         buffer.writeFlattenable(this->getMaskFilter());
         buffer.writeFlattenable(this->getColorFilter());
         buffer.writeFlattenable(this->getRasterizer());
         buffer.writeFlattenable(this->getLooper());
         buffer.writeFlattenable(this->getImageFilter());
+
+        if (fAnnotation) {
+            buffer.writeBool(true);
+            fAnnotation->writeToBuffer(buffer);
+        } else {
+            buffer.writeBool(false);
+        }
     }
 }
 
 void SkPaint::unflatten(SkReadBuffer& buffer) {
     SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
     if (!buffer.validateAvailable(kPODPaintSize)) {
         return;
     }
     const void* podData = buffer.skip(kPODPaintSize);
     const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
@@ skipping 23 matching lines @@
     if (flatFlags & kHasEffects_FlatFlag) {
         SkSafeUnref(this->setPathEffect(buffer.readPathEffect()));
         SkSafeUnref(this->setShader(buffer.readShader()));
         SkSafeUnref(this->setXfermode(buffer.readXfermode()));
         SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter()));
         SkSafeUnref(this->setColorFilter(buffer.readColorFilter()));
         SkSafeUnref(this->setRasterizer(buffer.readRasterizer()));
         SkSafeUnref(this->setLooper(buffer.readDrawLooper()));
         SkSafeUnref(this->setImageFilter(buffer.readImageFilter()));
 
-        if (buffer.isVersionLT(SkReadBuffer::kAnnotationsMovedToCanvas_Version)) {
-            // We used to store annotations here (string+skdata) if this bool was true
-            if (buffer.readBool()) {
-                // Annotations have moved to drawAnnotation, so we just drop this one on the floor.
-                SkString key;
-                buffer.readString(&key);
-                SkSafeUnref(buffer.readByteArrayAsData());
-            }
+        if (buffer.readBool()) {
+            this->setAnnotation(SkAnnotation::Create(buffer))->unref();
         }
     } else {
         this->setPathEffect(nullptr);
         this->setShader(nullptr);
         this->setXfermode(nullptr);
         this->setMaskFilter(nullptr);
         this->setColorFilter(nullptr);
         this->setRasterizer(nullptr);
         this->setLooper(nullptr);
         this->setImageFilter(nullptr);
@@ skipping 202 matching lines @@
         str->append("</dd>");
     }
 
     SkImageFilter* imageFilter = this->getImageFilter();
     if (imageFilter) {
         str->append("<dt>ImageFilter:</dt><dd>");
         imageFilter->toString(str);
         str->append("</dd>");
     }
 
+    SkAnnotation* annotation = this->getAnnotation();
+    if (annotation) {
+        str->append("<dt>Annotation:</dt><dd>");
+        str->append("</dd>");
+    }
+
     str->append("<dt>Color:</dt><dd>0x");
     SkColor color = this->getColor();
     str->appendHex(color);
     str->append("</dd>");
 
     str->append("<dt>Stroke Width:</dt><dd>");
     str->appendScalar(this->getStrokeWidth());
     str->append("</dd>");
 
     str->append("<dt>Stroke Miter:</dt><dd>");
@@ skipping 206 matching lines @@
             default:
                 break;
         }
     }
     return false;
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
-    static_assert(offsetof(SkPaint, fBitfields) == 9 * sizeof(void*) + 6 * sizeof(uint32_t),
+    static_assert(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
                   "SkPaint_notPackedTightly");
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }