Revert of move annotations to canvas virtual

src/pdf/SkPDFDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFDevice.h"
 
-#include "SkAnnotationKeys.h"
+#include "SkAnnotation.h"
 #include "SkColor.h"
 #include "SkColorFilter.h"
 #include "SkClipStack.h"
 #include "SkData.h"
 #include "SkDraw.h"
 #include "SkGlyphCache.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPathOps.h"
 #include "SkPDFBitmap.h"
@@ skipping 729 matching lines @@
     fShaderResources.unrefAll();
     fLinkToURLs.deleteAll();
     fLinkToDestinations.deleteAll();
     fNamedDestinations.deleteAll();
 
     if (clearFontUsage) {
         fFontGlyphUsage->reset();
     }
 }
 
-void SkPDFDevice::drawAnnotation(const SkDraw& d, const SkRect& rect, const char key[],
-                                 SkData* value) {
-    if (0 == rect.width() && 0 == rect.height()) {
-        handlePointAnnotation({ rect.x(), rect.y() }, *d.fMatrix, key, value);
-    } else {
-        SkPath path;
-        path.addRect(rect);
-        handlePathAnnotation(path, d, key, value);
-    }
-}
-
 void SkPDFDevice::drawPaint(const SkDraw& d, const SkPaint& paint) {
     SkPaint newPaint = paint;
     replace_srcmode_on_opaque_paint(&newPaint);
 
     newPaint.setStyle(SkPaint::kFill_Style);
     ScopedContentEntry content(this, d, newPaint);
     internalDrawPaint(newPaint, content.entry());
 }
 
 void SkPDFDevice::internalDrawPaint(const SkPaint& paint,
@@ skipping 19 matching lines @@
                              size_t count,
                              const SkPoint* points,
                              const SkPaint& srcPaint) {
     SkPaint passedPaint = srcPaint;
     replace_srcmode_on_opaque_paint(&passedPaint);
 
     if (count == 0) {
         return;
     }
 
+    if (SkAnnotation* annotation = passedPaint.getAnnotation()) {
+        if (handlePointAnnotation(points, count, *d.fMatrix, annotation)) {
+            return;
+        }
+    }
+
     // SkDraw::drawPoints converts to multiple calls to fDevice->drawPath.
     // We only use this when there's a path effect because of the overhead
     // of multiple calls to setUpContentEntry it causes.
     if (passedPaint.getPathEffect()) {
         if (d.fClip->isEmpty()) {
             return;
         }
         SkDraw pointDraw(d);
         pointDraw.fDevice = this;
         pointDraw.drawPoints(mode, count, points, passedPaint, true);
@@ skipping 117 matching lines @@
     if (paint.getPathEffect()) {
         if (d.fClip->isEmpty()) {
             return;
         }
         SkPath path;
         path.addRect(r);
         drawPath(d, path, paint, nullptr, true);
         return;
     }
 
+    if (SkAnnotation* annotation = paint.getAnnotation()) {
+        SkPath path;
+        path.addRect(rect);
+        if (handlePathAnnotation(path, d, annotation)) {
+            return;
+        }
+    }
+
     ScopedContentEntry content(this, d, paint);
     if (!content.entry()) {
         return;
     }
     SkPDFUtils::AppendRectangle(r, &content.entry()->fContent);
     SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
                           &content.entry()->fContent);
 }
 
 void SkPDFDevice::drawRRect(const SkDraw& draw,
@@ skipping 58 matching lines @@
             noEffectPaint.setStrokeWidth(0);
         }
         drawPath(d, *pathPtr, noEffectPaint, nullptr, true);
         return;
     }
 
     if (handleInversePath(d, origPath, paint, pathIsMutable, prePathMatrix)) {
         return;
     }
 
+    if (SkAnnotation* annotation = paint.getAnnotation()) {
+        if (handlePathAnnotation(*pathPtr, d, annotation)) {
+            return;
+        }
+    }
+
     ScopedContentEntry content(this, d.fClipStack, *d.fClip, matrix, paint);
     if (!content.entry()) {
         return;
     }
     bool consumeDegeratePathSegments =
            paint.getStyle() == SkPaint::kFill_Style ||
            (paint.getStrokeCap() != SkPaint::kRound_Cap &&
             paint.getStrokeCap() != SkPaint::kSquare_Cap);
     SkPDFUtils::EmitPath(*pathPtr, paint.getStyle(),
                          consumeDegeratePathSegments,
@@ skipping 633 matching lines @@
                   paint.getStrokeWidth() + SK_Scalar1);
 
     if (!calculate_inverse_path(bounds, *pathPtr, &modifiedPath)) {
         return false;
     }
 
     drawPath(d, modifiedPath, noInversePaint, prePathMatrix, true);
     return true;
 }
 
-void SkPDFDevice::handlePointAnnotation(const SkPoint& point,
+bool SkPDFDevice::handlePointAnnotation(const SkPoint* points, size_t count,
                                         const SkMatrix& matrix,
-                                        const char key[], SkData* value) {
-    if (!value) {
-        return;
+                                        SkAnnotation* annotationInfo) {
+    SkData* nameData = annotationInfo->find(
+            SkAnnotationKeys::Define_Named_Dest_Key());
+    if (nameData) {
+        for (size_t i = 0; i < count; i++) {
+            SkPoint transformedPoint;
+            matrix.mapXY(points[i].x(), points[i].y(), &transformedPoint);
+            fNamedDestinations.push(new NamedDestination(nameData, transformedPoint));
+        }
+        return true;
     }
-
-    if (!strcmp(SkAnnotationKeys::Define_Named_Dest_Key(), key)) {
-        SkPoint transformedPoint;
-        matrix.mapXY(point.x(), point.y(), &transformedPoint);
-        fNamedDestinations.push(new NamedDestination(value, transformedPoint));
-    }
+    return false;
 }
 
-void SkPDFDevice::handlePathAnnotation(const SkPath& path,
+bool SkPDFDevice::handlePathAnnotation(const SkPath& path,
                                        const SkDraw& d,
-                                       const char key[], SkData* value) {
-    if (!value) {
-        return;
-    }
+                                       SkAnnotation* annotation) {
+    SkASSERT(annotation);
 
     SkPath transformedPath = path;
     transformedPath.transform(*d.fMatrix);
     SkRasterClip clip = *d.fRC;
     clip.op(transformedPath, SkIRect::MakeWH(width(), height()), SkRegion::kIntersect_Op,
             false);
     SkRect transformedRect = SkRect::Make(clip.getBounds());
 
-    if (!strcmp(SkAnnotationKeys::URL_Key(), key)) {
+    SkData* urlData = annotation->find(SkAnnotationKeys::URL_Key());
+    if (urlData) {
         if (!transformedRect.isEmpty()) {
-            fLinkToURLs.push(new RectWithData(transformedRect, value));
+            fLinkToURLs.push(new RectWithData(transformedRect, urlData));
         }
-    } else if (!strcmp(SkAnnotationKeys::Link_Named_Dest_Key(), key)) {
+        return true;
+    }
+
+    SkData* linkToDestination =
+            annotation->find(SkAnnotationKeys::Link_Named_Dest_Key());
+    if (linkToDestination) {
         if (!transformedRect.isEmpty()) {
-            fLinkToDestinations.push(new RectWithData(transformedRect, value));
+            fLinkToDestinations.push(new RectWithData(transformedRect, linkToDestination));
         }
+        return true;
     }
+
+    return false;
 }
 
 void SkPDFDevice::appendAnnotations(SkPDFArray* array) const {
     array->reserve(fLinkToURLs.count() + fLinkToDestinations.count());
     for (RectWithData* rectWithURL : fLinkToURLs) {
         SkRect r;
         fInitialTransform.mapRect(&r, rectWithURL->rect);
         array->appendObject(create_link_to_url(rectWithURL->data, r));
     }
     for (RectWithData* linkToDestination : fLinkToDestinations) {
@@ skipping 622 matching lines @@
         pdfimage.reset(SkPDFCreateBitmapObject(
                                image, fCanon->fPixelSerializer));
         if (!pdfimage) {
             return;
         }
         fCanon->addPDFBitmap(image->uniqueID(), pdfimage);
     }
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }