text: /*
   * 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 "SkAdvancedTypefaceMetrics.h"
  #include "SkAnnotationKeys.h"
  #include "SkBitmapDevice.h"
  #include "SkBitmapKey.h"
  #include "SkCanvas.h"
  #include "SkClipOpPriv.h"
  #include "SkClusterator.h"
  #include "SkColor.h"
  #include "SkColorFilter.h"
  #include "SkDraw.h"
  #include "SkGlyphCache.h"
  #include "SkGlyphRun.h"
  #include "SkImageFilterCache.h"
  #include "SkJpegEncoder.h"
  #include "SkMakeUnique.h"
  #include "SkMaskFilterBase.h"
  #include "SkPDFBitmap.h"
  #include "SkPDFCanon.h"
  #include "SkPDFDocument.h"
  #include "SkPDFFont.h"
  #include "SkPDFFormXObject.h"
  #include "SkPDFGraphicState.h"
  #include "SkPDFResourceDict.h"
  #include "SkPDFShader.h"
  #include "SkPDFTypes.h"
  #include "SkPDFUtils.h"
  #include "SkPath.h"
  #include "SkPathEffect.h"
  #include "SkPathOps.h"
  #include "SkPixelRef.h"
  #include "SkRRect.h"
  #include "SkRasterClip.h"
  #include "SkScopeExit.h"
  #include "SkString.h"
  #include "SkSurface.h"
  #include "SkTemplates.h"
  #include "SkTextBlob.h"
  #include "SkTextFormatParams.h"
  #include "SkTo.h"
  #include "SkUTF.h"
  #include "SkXfermodeInterpretation.h"
  
  #ifndef SK_PDF_MASK_QUALITY
      // If MASK_QUALITY is in [0,100], will be used for JpegEncoder.
      // Otherwise, just encode masks losslessly.
      #define SK_PDF_MASK_QUALITY 50
      // Since these masks are used for blurry shadows, we shouldn't need
      // high quality.  Raise this value if your shadows have visible JPEG
      // artifacts.
      // If SkJpegEncoder::Encode fails, we will fall back to the lossless
      // encoding.
  #endif
  
  // Utility functions
  
  // This function destroys the mask and either frees or takes the pixels.
  sk_sp<SkImage> mask_to_greyscale_image(SkMask* mask) {
      sk_sp<SkImage> img;
      SkPixmap pm(SkImageInfo::Make(mask->fBounds.width(), mask->fBounds.height(),
                                    kGray_8_SkColorType, kOpaque_SkAlphaType),
                  mask->fImage, mask->fRowBytes);
      const int imgQuality = SK_PDF_MASK_QUALITY;
      if (imgQuality <= 100 && imgQuality >= 0) {
          SkDynamicMemoryWStream buffer;
          SkJpegEncoder::Options jpegOptions;
          jpegOptions.fQuality = imgQuality;
          if (SkJpegEncoder::Encode(&buffer, pm, jpegOptions)) {
              img = SkImage::MakeFromEncoded(buffer.detachAsData());
              SkASSERT(img);
              if (img) {
                  SkMask::FreeImage(mask->fImage);
              }
          }
      }
      if (!img) {
          img = SkImage::MakeFromRaster(pm, [](const void* p, void*) { SkMask::FreeImage((void*)p); },
                                        nullptr);
      }
      *mask = SkMask();  // destructive;
      return img;
  }
  
  sk_sp<SkImage> alpha_image_to_greyscale_image(const SkImage* mask) {
      int w = mask->width(), h = mask->height();
      SkBitmap greyBitmap;
      greyBitmap.allocPixels(SkImageInfo::Make(w, h, kGray_8_SkColorType, kOpaque_SkAlphaType));
      if (!mask->readPixels(SkImageInfo::MakeA8(w, h),
                            greyBitmap.getPixels(), greyBitmap.rowBytes(), 0, 0)) {
          return nullptr;
      }
      return SkImage::MakeFromBitmap(greyBitmap);
  }
  
  static void draw_points(SkCanvas::PointMode mode,
                          size_t count,
                          const SkPoint* points,
                          const SkPaint& paint,
                          const SkIRect& bounds,
                          const SkMatrix& ctm,
                          SkBaseDevice* device) {
      SkRasterClip rc(bounds);
      SkDraw draw;
      draw.fDst = SkPixmap(SkImageInfo::MakeUnknown(bounds.right(), bounds.bottom()), nullptr, 0);
      draw.fMatrix = &ctm;
      draw.fRC = &rc;
      draw.drawPoints(mode, count, points, paint, device);
  }
  
  // If the paint will definitely draw opaquely, replace kSrc with
  // kSrcOver.  http://crbug.com/473572
  static void replace_srcmode_on_opaque_paint(SkPaint* paint) {
      if (kSrcOver_SkXfermodeInterpretation == SkInterpretXfermode(*paint, false)) {
          paint->setBlendMode(SkBlendMode::kSrcOver);
      }
  }
  
  // A shader's matrix is:  CTMM x LocalMatrix x WrappingLocalMatrix.  We want to
  // switch to device space, where CTM = I, while keeping the original behavior.
  //
  //               I * LocalMatrix * NewWrappingMatrix = CTM * LocalMatrix
  //                   LocalMatrix * NewWrappingMatrix = CTM * LocalMatrix
  //  InvLocalMatrix * LocalMatrix * NewWrappingMatrix = InvLocalMatrix * CTM * LocalMatrix
  //                                 NewWrappingMatrix = InvLocalMatrix * CTM * LocalMatrix
  //
  static void transform_shader(SkPaint* paint, const SkMatrix& ctm) {
      SkMatrix lm = SkPDFUtils::GetShaderLocalMatrix(paint->getShader());
      SkMatrix lmInv;
      if (lm.invert(&lmInv)) {
          SkMatrix m = SkMatrix::Concat(SkMatrix::Concat(lmInv, ctm), lm);
          paint->setShader(paint->getShader()->makeWithLocalMatrix(m));
      }
  }
  
  static void emit_pdf_color(SkColor color, SkWStream* result) {
      SkASSERT(SkColorGetA(color) == 0xFF);  // We handle alpha elsewhere.
      SkPDFUtils::AppendColorComponent(SkColorGetR(color), result);
      result->writeText(" ");
      SkPDFUtils::AppendColorComponent(SkColorGetG(color), result);
      result->writeText(" ");
      SkPDFUtils::AppendColorComponent(SkColorGetB(color), result);
      result->writeText(" ");
  }
  
  static SkPaint calculate_text_paint(const SkPaint& paint) {
      SkPaint result = paint;
      if (result.isFakeBoldText()) {
          SkScalar fakeBoldScale = SkScalarInterpFunc(result.getTextSize(),
                                                      kStdFakeBoldInterpKeys,
                                                      kStdFakeBoldInterpValues,
                                                      kStdFakeBoldInterpLength);
          SkScalar width = result.getTextSize() * fakeBoldScale;
          if (result.getStyle() == SkPaint::kFill_Style) {
              result.setStyle(SkPaint::kStrokeAndFill_Style);
          } else {
              width += result.getStrokeWidth();
          }
          result.setStrokeWidth(width);
      }
      return result;
  }
  
  
  // If the paint has a color filter, apply the color filter to the shader or the
  // paint color.  Remove the color filter.
  void remove_color_filter(SkPaint* paint) {
      if (SkColorFilter* cf = paint->getColorFilter()) {
          if (SkShader* shader = paint->getShader()) {
              paint->setShader(shader->makeWithColorFilter(paint->refColorFilter()));
          } else {
              paint->setColor(cf->filterColor(paint->getColor()));
          }
          paint->setColorFilter(nullptr);
      }
  }
  
  SkPDFDevice::GraphicStateEntry::GraphicStateEntry()
      : fColor(SK_ColorBLACK)
      , fTextScaleX(SK_Scalar1)
      , fTextFill(SkPaint::kFill_Style)
      , fShaderIndex(-1)
      , fGraphicStateIndex(-1) {
      fMatrix.reset();
  }
  
  bool SkPDFDevice::GraphicStateEntry::compareInitialState(
          const GraphicStateEntry& cur) {
      return fColor == cur.fColor &&
             fShaderIndex == cur.fShaderIndex &&
             fGraphicStateIndex == cur.fGraphicStateIndex &&
             fMatrix == cur.fMatrix &&
             fClipStack == cur.fClipStack &&
             (fTextScaleX == 0 ||
                 (fTextScaleX == cur.fTextScaleX && fTextFill == cur.fTextFill));
  }
  
  class GraphicStackState {
  public:
      GraphicStackState(const SkClipStack& existingClipStack,
                        SkWStream* contentStream)
              : fStackDepth(0),
                fContentStream(contentStream) {
          fEntries[0].fClipStack = existingClipStack;
      }
  
      void updateClip(const SkClipStack& clipStack, const SkIRect& bounds);
      void updateMatrix(const SkMatrix& matrix);
      void updateDrawingState(const SkPDFDevice::GraphicStateEntry& state);
  
      void drainStack();
  
  private:
      void push();
      void pop();
      SkPDFDevice::GraphicStateEntry* currentEntry() { return &fEntries[fStackDepth]; }
  
      // Conservative limit on save depth, see impl. notes in PDF 1.4 spec.
      static const int kMaxStackDepth = 12;
      SkPDFDevice::GraphicStateEntry fEntries[kMaxStackDepth + 1];
      int fStackDepth;
      SkWStream* fContentStream;
  };
  
  void GraphicStackState::drainStack() {
      while (fStackDepth) {
          pop();
      }
  }
  
  void GraphicStackState::push() {
      SkASSERT(fStackDepth < kMaxStackDepth);
      fContentStream->writeText("q\n");
      fStackDepth++;
      fEntries[fStackDepth] = fEntries[fStackDepth - 1];
  }
  
  void GraphicStackState::pop() {
      SkASSERT(fStackDepth > 0);
      fContentStream->writeText("Q\n");
      fStackDepth--;
  }
  
  /* Calculate an inverted path's equivalent non-inverted path, given the
   * canvas bounds.
   * outPath may alias with invPath (since this is supported by PathOps).
   */
  static bool calculate_inverse_path(const SkRect& bounds, const SkPath& invPath,
                                     SkPath* outPath) {
      SkASSERT(invPath.isInverseFillType());
  
      SkPath clipPath;
      clipPath.addRect(bounds);
  
      return Op(clipPath, invPath, kIntersect_SkPathOp, outPath);
  }
  
  bool apply_clip(SkClipOp op, const SkPath& u, const SkPath& v, SkPath* r)  {
      switch (op) {
          case SkClipOp::kDifference:
              return Op(u, v, kDifference_SkPathOp, r);
          case SkClipOp::kIntersect:
              return Op(u, v, kIntersect_SkPathOp, r);
  #ifdef SK_SUPPORT_DEPRECATED_CLIPOPS
          case SkClipOp::kUnion_deprecated:
              return Op(u, v, kUnion_SkPathOp, r);
          case SkClipOp::kXOR_deprecated:
              return Op(u, v, kXOR_SkPathOp, r);
          case SkClipOp::kReverseDifference_deprecated:
              return Op(u, v, kReverseDifference_SkPathOp, r);
          case SkClipOp::kReplace_deprecated:
              *r = v;
              return true;
  #endif
          default:
              return false;
      }
  }
  
  static SkRect rect_intersect(SkRect u, SkRect v) {
      if (u.isEmpty() || v.isEmpty()) { return {0, 0, 0, 0}; }
      return u.intersect(v) ? u : SkRect{0, 0, 0, 0};
  }
  
  // Test to see if the clipstack is a simple rect, If so, we can avoid all PathOps code
  // and speed thing up.
  static bool is_rect(const SkClipStack& clipStack, const SkRect& bounds, SkRect* dst) {
      SkRect currentClip = bounds;
      SkClipStack::Iter iter(clipStack, SkClipStack::Iter::kBottom_IterStart);
      while (const SkClipStack::Element* element = iter.next()) {
          SkRect elementRect{0, 0, 0, 0};
          switch (element->getDeviceSpaceType()) {
              case SkClipStack::Element::DeviceSpaceType::kEmpty:
                  break;
              case SkClipStack::Element::DeviceSpaceType::kRect:
                  elementRect = element->getDeviceSpaceRect();
                  break;
              default:
                  return false;
          }
          switch (element->getOp()) {
              case kReplace_SkClipOp:
                  currentClip = rect_intersect(bounds, elementRect);
                  break;
              case SkClipOp::kIntersect:
                  currentClip = rect_intersect(currentClip, elementRect);
                  break;
              default:
                  return false;
          }
      }
      *dst = currentClip;
      return true;
  }
  
  static void append_clip(const SkClipStack& clipStack,
                          const SkIRect& bounds,
                          SkWStream* wStream) {
      // The bounds are slightly outset to ensure this is correct in the
      // face of floating-point accuracy and possible SkRegion bitmap
      // approximations.
      SkRect outsetBounds = SkRect::Make(bounds.makeOutset(1, 1));
  
      SkRect clipStackRect;
      if (is_rect(clipStack, outsetBounds, &clipStackRect)) {
          SkPDFUtils::AppendRectangle(clipStackRect, wStream);
          wStream->writeText("W* n\n");
          return;
      }
  
      SkPath clipPath;
      (void)clipStack.asPath(&clipPath);
  
      SkPath clipBoundsPath;
      clipBoundsPath.addRect(outsetBounds);
  
      if (Op(clipPath, clipBoundsPath, kIntersect_SkPathOp, &clipPath)) {
          SkPDFUtils::EmitPath(clipPath, SkPaint::kFill_Style, wStream);
          SkPath::FillType clipFill = clipPath.getFillType();
          NOT_IMPLEMENTED(clipFill == SkPath::kInverseEvenOdd_FillType, false);
          NOT_IMPLEMENTED(clipFill == SkPath::kInverseWinding_FillType, false);
          if (clipFill == SkPath::kEvenOdd_FillType) {
              wStream->writeText("W* n\n");
          } else {
              wStream->writeText("W n\n");
          }
      }
      // If Op() fails (pathological case; e.g. input values are
      // extremely large or NaN), emit no clip at all.
  }
  
  // TODO(vandebo): Take advantage of SkClipStack::getSaveCount(), the PDF
  // graphic state stack, and the fact that we can know all the clips used
  // on the page to optimize this.
  void GraphicStackState::updateClip(const SkClipStack& clipStack,
                                     const SkIRect& bounds) {
      if (clipStack == currentEntry()->fClipStack) {
          return;
      }
  
      while (fStackDepth > 0) {
          pop();
          if (clipStack == currentEntry()->fClipStack) {
              return;
          }
      }
      push();
  
      currentEntry()->fClipStack = clipStack;
      append_clip(clipStack, bounds, fContentStream);
  }
  
  void GraphicStackState::updateMatrix(const SkMatrix& matrix) {
      if (matrix == currentEntry()->fMatrix) {
          return;
      }
  
      if (currentEntry()->fMatrix.getType() != SkMatrix::kIdentity_Mask) {
          SkASSERT(fStackDepth > 0);
          SkASSERT(fEntries[fStackDepth].fClipStack ==
                   fEntries[fStackDepth -1].fClipStack);
          pop();
  
          SkASSERT(currentEntry()->fMatrix.getType() == SkMatrix::kIdentity_Mask);
      }
      if (matrix.getType() == SkMatrix::kIdentity_Mask) {
          return;
      }
  
      push();
      SkPDFUtils::AppendTransform(matrix, fContentStream);
      currentEntry()->fMatrix = matrix;
  }
  
  void GraphicStackState::updateDrawingState(const SkPDFDevice::GraphicStateEntry& state) {
      // PDF treats a shader as a color, so we only set one or the other.
      if (state.fShaderIndex >= 0) {
          if (state.fShaderIndex != currentEntry()->fShaderIndex) {
              SkPDFUtils::ApplyPattern(state.fShaderIndex, fContentStream);
              currentEntry()->fShaderIndex = state.fShaderIndex;
          }
      } else {
          if (state.fColor != currentEntry()->fColor ||
                  currentEntry()->fShaderIndex >= 0) {
              emit_pdf_color(state.fColor, fContentStream);
              fContentStream->writeText("RG ");
              emit_pdf_color(state.fColor, fContentStream);
              fContentStream->writeText("rg\n");
              currentEntry()->fColor = state.fColor;
              currentEntry()->fShaderIndex = -1;
          }
      }
  
      if (state.fGraphicStateIndex != currentEntry()->fGraphicStateIndex) {
          SkPDFUtils::ApplyGraphicState(state.fGraphicStateIndex, fContentStream);
          currentEntry()->fGraphicStateIndex = state.fGraphicStateIndex;
      }
  
      if (state.fTextScaleX) {
          if (state.fTextScaleX != currentEntry()->fTextScaleX) {
              SkScalar pdfScale = state.fTextScaleX * 100;
              SkPDFUtils::AppendScalar(pdfScale, fContentStream);
              fContentStream->writeText(" Tz\n");
              currentEntry()->fTextScaleX = state.fTextScaleX;
          }
          if (state.fTextFill != currentEntry()->fTextFill) {
              static_assert(SkPaint::kFill_Style == 0, "enum_must_match_value");
              static_assert(SkPaint::kStroke_Style == 1, "enum_must_match_value");
              static_assert(SkPaint::kStrokeAndFill_Style == 2, "enum_must_match_value");
              fContentStream->writeDecAsText(state.fTextFill);
              fContentStream->writeText(" Tr\n");
              currentEntry()->fTextFill = state.fTextFill;
          }
      }
  }
  
  static bool not_supported_for_layers(const SkPaint& layerPaint) {
      // PDF does not support image filters, so render them on CPU.
      // Note that this rendering is done at "screen" resolution (100dpi), not
      // printer resolution.
      // TODO: It may be possible to express some filters natively using PDF
      // to improve quality and file size (https://bug.skia.org/3043)
  
      // TODO: should we return true if there is a colorfilter?
      return layerPaint.getImageFilter() != nullptr;
  }
  
  SkBaseDevice* SkPDFDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint* layerPaint) {
      if (layerPaint && not_supported_for_layers(*layerPaint)) {
          // need to return a raster device, which we will detect in drawDevice()
          return SkBitmapDevice::Create(cinfo.fInfo, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
      }
      return new SkPDFDevice(cinfo.fInfo.dimensions(), fDocument);
  }
  
  SkPDFCanon* SkPDFDevice::getCanon() const { return fDocument->canon(); }
  
  // A helper class to automatically finish a ContentEntry at the end of a
  // drawing method and maintain the state needed between set up and finish.
  class ScopedContentEntry {
  public:
      ScopedContentEntry(SkPDFDevice* device,
                         const SkClipStack& clipStack,
                         const SkMatrix& matrix,
                         const SkPaint& paint,
                         bool hasText = false)
          : fDevice(device)
          , fContentEntry(nullptr)
          , fBlendMode(SkBlendMode::kSrcOver)
          , fDstFormXObject(nullptr)
      {
          if (matrix.hasPerspective()) {
              NOT_IMPLEMENTED(!matrix.hasPerspective(), false);
              return;
          }
          fBlendMode = paint.getBlendMode();
          fContentEntry =
              fDevice->setUpContentEntry(clipStack, matrix, paint, hasText, &fDstFormXObject);
      }
      ScopedContentEntry(SkPDFDevice* dev, const SkPaint& paint, bool hasText = false)
          : ScopedContentEntry(dev, dev->cs(), dev->ctm(), paint, hasText) {}
  
      ~ScopedContentEntry() {
          if (fContentEntry) {
              SkPath* shape = &fShape;
              if (shape->isEmpty()) {
                  shape = nullptr;
              }
              fDevice->finishContentEntry(fBlendMode, std::move(fDstFormXObject), shape);
          }
      }
  
      SkPDFDevice::ContentEntry* entry() { return fContentEntry; }
      SkDynamicMemoryWStream* stream() { return &fContentEntry->fContent; }
  
      /* Returns true when we explicitly need the shape of the drawing. */
      bool needShape() {
          switch (fBlendMode) {
              case SkBlendMode::kClear:
              case SkBlendMode::kSrc:
              case SkBlendMode::kSrcIn:
              case SkBlendMode::kSrcOut:
              case SkBlendMode::kDstIn:
              case SkBlendMode::kDstOut:
              case SkBlendMode::kSrcATop:
              case SkBlendMode::kDstATop:
              case SkBlendMode::kModulate:
                  return true;
              default:
                  return false;
          }
      }
  
      /* Returns true unless we only need the shape of the drawing. */
      bool needSource() {
          if (fBlendMode == SkBlendMode::kClear) {
              return false;
          }
          return true;
      }
  
      /* If the shape is different than the alpha component of the content, then
       * setShape should be called with the shape.  In particular, images and
       * devices have rectangular shape.
       */
      void setShape(const SkPath& shape) {
          fShape = shape;
      }
  
  private:
      SkPDFDevice* fDevice;
      SkPDFDevice::ContentEntry* fContentEntry;
      SkBlendMode fBlendMode;
      sk_sp<SkPDFObject> fDstFormXObject;
      SkPath fShape;
  };
  
  ////////////////////////////////////////////////////////////////////////////////
  
  SkPDFDevice::SkPDFDevice(SkISize pageSize, SkPDFDocument* doc)
      : INHERITED(SkImageInfo::MakeUnknown(pageSize.width(), pageSize.height()),
                  SkSurfaceProps(0, kUnknown_SkPixelGeometry))
      , fPageSize(pageSize)
      , fInitialTransform(SkMatrix::I())
      , fDocument(doc)
  {
      SkASSERT(!pageSize.isEmpty());
  }
  
  void SkPDFDevice::setFlip() {
      // Skia generally uses the top left as the origin but PDF
      // natively has the origin at the bottom left. This matrix
      // corrects for that.  But that only needs to be done once, we
      // don't do it when layering.
      SkScalar rasterScale = SkPDFUtils::kDpiForRasterScaleOne / fDocument->rasterDpi();
      fInitialTransform.setConcat(SkMatrix::MakeScale(rasterScale, -rasterScale),
                                  SkMatrix::MakeTrans(0, -fPageSize.fHeight));
  }
  
  SkPDFDevice::~SkPDFDevice() {
      this->cleanUp();
  }
  
  void SkPDFDevice::init() {
      fContentEntries.reset();
  }
  
  void SkPDFDevice::cleanUp() {
      fGraphicStateResources.unrefAll();
      fXObjectResources.unrefAll();
      fFontResources.unrefAll();
      fShaderResources.unrefAll();
  }
  
  void SkPDFDevice::drawAnnotation(const SkRect& rect, const char key[], SkData* value) {
      if (!value) {
          return;
      }
      if (rect.isEmpty()) {
          if (!strcmp(SkAnnotationKeys::Define_Named_Dest_Key(), key)) {
              SkPoint transformedPoint;
              this->ctm().mapXY(rect.x(), rect.y(), &transformedPoint);
              fNamedDestinations.emplace_back(NamedDestination{sk_ref_sp(value), transformedPoint});
          }
          return;
      }
      // Convert to path to handle non-90-degree rotations.
      SkPath path;
      path.addRect(rect);
      path.transform(this->ctm(), &path);
      SkPath clip;
      (void)this->cs().asPath(&clip);
      Op(clip, path, kIntersect_SkPathOp, &path);
      // PDF wants a rectangle only.
      SkRect transformedRect = path.getBounds();
      if (transformedRect.isEmpty()) {
          return;
      }
      if (!strcmp(SkAnnotationKeys::URL_Key(), key)) {
          fLinkToURLs.emplace_back(RectWithData{transformedRect, sk_ref_sp(value)});
      } else if (!strcmp(SkAnnotationKeys::Link_Named_Dest_Key(), key)) {
          fLinkToDestinations.emplace_back(RectWithData{transformedRect, sk_ref_sp(value)});
      }
  }
  
  void SkPDFDevice::drawPaint(const SkPaint& srcPaint) {
      if (this->hasEmptyClip()) {
          return;
      }
      SkPaint newPaint = srcPaint;
      remove_color_filter(&newPaint);
      replace_srcmode_on_opaque_paint(&newPaint);
      newPaint.setStyle(SkPaint::kFill_Style);
  
      SkMatrix ctm = this->ctm();
      if (ctm.getType() & SkMatrix::kPerspective_Mask) {
          if (newPaint.getShader()) {
              transform_shader(&newPaint, ctm);
          }
          ctm = SkMatrix::I();
      }
      ScopedContentEntry content(this, this->cs(), ctm, newPaint);
      this->internalDrawPaint(newPaint, content.entry());
  }
  
  void SkPDFDevice::internalDrawPaint(const SkPaint& paint,
                                      SkPDFDevice::ContentEntry* contentEntry) {
      if (!contentEntry) {
          return;
      }
      SkRect bbox = SkRect::Make(fPageSize);
      SkMatrix inverse;
      if (!contentEntry->fState.fMatrix.invert(&inverse)) {
          return;
      }
      inverse.mapRect(&bbox);
  
      SkPDFUtils::AppendRectangle(bbox, &contentEntry->fContent);
      SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
                            &contentEntry->fContent);
  }
  
  void SkPDFDevice::drawPoints(SkCanvas::PointMode mode,
                               size_t count,
                               const SkPoint* points,
                               const SkPaint& srcPaint) {
      if (this->hasEmptyClip()) {
          return;
      }
      SkPaint passedPaint = srcPaint;
      remove_color_filter(&passedPaint);
      replace_srcmode_on_opaque_paint(&passedPaint);
      if (SkCanvas::kPoints_PointMode != mode) {
          passedPaint.setStyle(SkPaint::kStroke_Style);
      }
      if (count == 0) {
          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()) {
          draw_points(mode, count, points, passedPaint,
                      this->devClipBounds(), this->ctm(), this);
          return;
      }
  
      const SkPaint* paint = &passedPaint;
      SkPaint modifiedPaint;
  
      if (mode == SkCanvas::kPoints_PointMode &&
              paint->getStrokeCap() != SkPaint::kRound_Cap) {
          modifiedPaint = *paint;
          paint = &modifiedPaint;
          if (paint->getStrokeWidth()) {
              // PDF won't draw a single point with square/butt caps because the
              // orientation is ambiguous.  Draw a rectangle instead.
              modifiedPaint.setStyle(SkPaint::kFill_Style);
              SkScalar strokeWidth = paint->getStrokeWidth();
              SkScalar halfStroke = SkScalarHalf(strokeWidth);
              for (size_t i = 0; i < count; i++) {
                  SkRect r = SkRect::MakeXYWH(points[i].fX, points[i].fY, 0, 0);
                  r.inset(-halfStroke, -halfStroke);
                  this->drawRect(r, modifiedPaint);
              }
              return;
          } else {
              modifiedPaint.setStrokeCap(SkPaint::kRound_Cap);
          }
      }
  
      ScopedContentEntry content(this, *paint);
      if (!content.entry()) {
          return;
      }
      SkDynamicMemoryWStream* contentStream = content.stream();
      switch (mode) {
          case SkCanvas::kPolygon_PointMode:
              SkPDFUtils::MoveTo(points[0].fX, points[0].fY, contentStream);
              for (size_t i = 1; i < count; i++) {
                  SkPDFUtils::AppendLine(points[i].fX, points[i].fY, contentStream);
              }
              SkPDFUtils::StrokePath(contentStream);
              break;
          case SkCanvas::kLines_PointMode:
              for (size_t i = 0; i < count/2; i++) {
                  SkPDFUtils::MoveTo(points[i * 2].fX, points[i * 2].fY, contentStream);
                  SkPDFUtils::AppendLine(points[i * 2 + 1].fX, points[i * 2 + 1].fY, contentStream);
                  SkPDFUtils::StrokePath(contentStream);
              }
              break;
          case SkCanvas::kPoints_PointMode:
              SkASSERT(paint->getStrokeCap() == SkPaint::kRound_Cap);
              for (size_t i = 0; i < count; i++) {
                  SkPDFUtils::MoveTo(points[i].fX, points[i].fY, contentStream);
                  SkPDFUtils::ClosePath(contentStream);
                  SkPDFUtils::StrokePath(contentStream);
              }
              break;
          default:
              SkASSERT(false);
      }
  }
  
  static sk_sp<SkPDFDict> create_link_annotation(const SkRect& translatedRect) {
      auto annotation = sk_make_sp<SkPDFDict>("Annot");
      annotation->insertName("Subtype", "Link");
      annotation->insertInt("F", 4);  // required by ISO 19005
  
      auto border = sk_make_sp<SkPDFArray>();
      border->reserve(3);
      border->appendInt(0);  // Horizontal corner radius.
      border->appendInt(0);  // Vertical corner radius.
      border->appendInt(0);  // Width, 0 = no border.
      annotation->insertObject("Border", std::move(border));
  
      auto rect = sk_make_sp<SkPDFArray>();
      rect->reserve(4);
      rect->appendScalar(translatedRect.fLeft);
      rect->appendScalar(translatedRect.fTop);
      rect->appendScalar(translatedRect.fRight);
      rect->appendScalar(translatedRect.fBottom);
      annotation->insertObject("Rect", std::move(rect));
  
      return annotation;
  }
  
  static sk_sp<SkPDFDict> create_link_to_url(const SkData* urlData, const SkRect& r) {
      sk_sp<SkPDFDict> annotation = create_link_annotation(r);
      SkString url(static_cast<const char *>(urlData->data()),
                   urlData->size() - 1);
      auto action = sk_make_sp<SkPDFDict>("Action");
      action->insertName("S", "URI");
      action->insertString("URI", url);
      annotation->insertObject("A", std::move(action));
      return annotation;
  }
  
  static sk_sp<SkPDFDict> create_link_named_dest(const SkData* nameData,
                                                 const SkRect& r) {
      sk_sp<SkPDFDict> annotation = create_link_annotation(r);
      SkString name(static_cast<const char *>(nameData->data()),
                    nameData->size() - 1);
      annotation->insertName("Dest", name);
      return annotation;
  }
  
  void SkPDFDevice::drawRect(const SkRect& rect,
                             const SkPaint& srcPaint) {
      if (this->hasEmptyClip()) {
          return;
      }
      SkPaint paint = srcPaint;
      remove_color_filter(&paint);
      replace_srcmode_on_opaque_paint(&paint);
      SkRect r = rect;
      r.sort();
  
      if (paint.getPathEffect() || paint.getMaskFilter()) {
          SkPath path;
          path.addRect(r);
          this->drawPath(path, paint, true);
          return;
      }
  
      ScopedContentEntry content(this, paint);
      if (!content.entry()) {
          return;
      }
      SkPDFUtils::AppendRectangle(r, content.stream());
      SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType, content.stream());
  }
  
  void SkPDFDevice::drawRRect(const SkRRect& rrect,
                              const SkPaint& srcPaint) {
      if (this->hasEmptyClip()) {
          return;
      }
      SkPaint paint = srcPaint;
      remove_color_filter(&paint);
      replace_srcmode_on_opaque_paint(&paint);
      SkPath  path;
      path.addRRect(rrect);
      this->drawPath(path, paint, true);
  }
  
  void SkPDFDevice::drawOval(const SkRect& oval,
                             const SkPaint& srcPaint) {
      if (this->hasEmptyClip()) {
          return;
      }
      SkPaint paint = srcPaint;
      remove_color_filter(&paint);
      replace_srcmode_on_opaque_paint(&paint);
      SkPath  path;
      path.addOval(oval);
      this->drawPath(path, paint, true);
  }
  
  void SkPDFDevice::drawPath(const SkPath& origPath,
                             const SkPaint& srcPaint,
                             bool pathIsMutable) {
      this->internalDrawPath(this->cs(), this->ctm(), origPath, srcPaint, pathIsMutable);
  }
  
  void SkPDFDevice::internalDrawPathWithFilter(const SkClipStack& clipStack,
                                               const SkMatrix& ctm,
                                               const SkPath& origPath,
                                               const SkPaint& origPaint) {
      SkASSERT(origPaint.getMaskFilter());
      SkPath path(origPath);
      SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
  
      SkStrokeRec::InitStyle initStyle = paint->getFillPath(path, &path)
                                       ? SkStrokeRec::kFill_InitStyle
                                       : SkStrokeRec::kHairline_InitStyle;
      path.transform(ctm, &path);
  
      SkIRect bounds = clipStack.bounds(this->bounds()).roundOut();
      SkMask sourceMask;
      if (!SkDraw::DrawToMask(path, &bounds, paint->getMaskFilter(), &SkMatrix::I(),
                              &sourceMask, SkMask::kComputeBoundsAndRenderImage_CreateMode,
                              initStyle)) {
          return;
      }
      SkAutoMaskFreeImage srcAutoMaskFreeImage(sourceMask.fImage);
      SkMask dstMask;
      SkIPoint margin;
      if (!as_MFB(paint->getMaskFilter())->filterMask(&dstMask, sourceMask, ctm, &margin)) {
          return;
      }
      SkIRect dstMaskBounds = dstMask.fBounds;
      sk_sp<SkImage> mask = mask_to_greyscale_image(&dstMask);
      // PDF doesn't seem to allow masking vector graphics with an Image XObject.
      // Must mask with a Form XObject.
      sk_sp<SkPDFDevice> maskDevice = this->makeCongruentDevice();
      {
          SkCanvas canvas(maskDevice);
          canvas.drawImage(mask, dstMaskBounds.x(), dstMaskBounds.y());
      }
      if (!ctm.isIdentity() && paint->getShader()) {
          transform_shader(paint.writable(), ctm); // Since we are using identity matrix.
      }
      ScopedContentEntry content(this, clipStack, SkMatrix::I(), *paint);
      if (!content.entry()) {
          return;
      }
      this->addSMaskGraphicState(std::move(maskDevice), content.stream());
      SkPDFUtils::AppendRectangle(SkRect::Make(dstMaskBounds), content.stream());
      SkPDFUtils::PaintPath(SkPaint::kFill_Style, path.getFillType(), content.stream());
      this->clearMaskOnGraphicState(content.stream());
  }
  
  void SkPDFDevice::addSMaskGraphicState(sk_sp<SkPDFDevice> maskDevice,
                                         SkDynamicMemoryWStream* contentStream) {
      sk_sp<SkPDFDict> sMaskGS = SkPDFGraphicState::GetSMaskGraphicState(
              maskDevice->makeFormXObjectFromDevice(true), false,
              SkPDFGraphicState::kLuminosity_SMaskMode, this->getCanon());
      SkPDFUtils::ApplyGraphicState(this->addGraphicStateResource(sMaskGS.get()), contentStream);
  }
  
  void SkPDFDevice::clearMaskOnGraphicState(SkDynamicMemoryWStream* contentStream) {
      // The no-softmask graphic state is used to "turn off" the mask for later draw calls.
      sk_sp<SkPDFDict>& noSMaskGS = this->getCanon()->fNoSmaskGraphicState;
      if (!noSMaskGS) {
          noSMaskGS = sk_make_sp<SkPDFDict>("ExtGState");
          noSMaskGS->insertName("SMask", "None");
      }
      SkPDFUtils::ApplyGraphicState(this->addGraphicStateResource(noSMaskGS.get()), contentStream);
  }
  
  void SkPDFDevice::internalDrawPath(const SkClipStack& clipStack,
                                     const SkMatrix& ctm,
                                     const SkPath& origPath,
                                     const SkPaint& srcPaint,
                                     bool pathIsMutable) {
      if (clipStack.isEmpty(this->bounds())) {
          return;
      }
      SkPaint paint = srcPaint;
      remove_color_filter(&paint);
      replace_srcmode_on_opaque_paint(&paint);
      SkPath modifiedPath;
      SkPath* pathPtr = const_cast<SkPath*>(&origPath);
  
      if (paint.getMaskFilter()) {
          this->internalDrawPathWithFilter(clipStack, ctm, origPath, paint);
          return;
      }
  
      SkMatrix matrix = ctm;
  
      if (paint.getPathEffect()) {
          if (clipStack.isEmpty(this->bounds())) {
              return;
          }
          if (!pathIsMutable) {
              modifiedPath = origPath;
              pathPtr = &modifiedPath;
              pathIsMutable = true;
          }
          if (paint.getFillPath(*pathPtr, pathPtr)) {
              paint.setStyle(SkPaint::kFill_Style);
          } else {
              paint.setStyle(SkPaint::kStroke_Style);
              paint.setStrokeWidth(0);
          }
          paint.setPathEffect(nullptr);
      }
  
      if (this->handleInversePath(*pathPtr, paint, pathIsMutable)) {
          return;
      }
      if (matrix.getType() & SkMatrix::kPerspective_Mask) {
          if (!pathIsMutable) {
              modifiedPath = origPath;
              pathPtr = &modifiedPath;
              pathIsMutable = true;
          }
          pathPtr->transform(matrix);
          if (paint.getShader()) {
              transform_shader(&paint, matrix);
          }
          matrix = SkMatrix::I();
      }
  
      ScopedContentEntry content(this, clipStack, matrix, paint);
      if (!content.entry()) {
          return;
      }
      constexpr SkScalar kToleranceScale = 0.0625f;  // smaller = better conics (circles).
      SkScalar matrixScale = matrix.mapRadius(1.0f);
      SkScalar tolerance = matrixScale > 0.0f ? kToleranceScale / matrixScale : kToleranceScale;
      bool consumeDegeratePathSegments =
             paint.getStyle() == SkPaint::kFill_Style ||
             (paint.getStrokeCap() != SkPaint::kRound_Cap &&
              paint.getStrokeCap() != SkPaint::kSquare_Cap);
      SkPDFUtils::EmitPath(*pathPtr, paint.getStyle(), consumeDegeratePathSegments, content.stream(),
                           tolerance);
      SkPDFUtils::PaintPath(paint.getStyle(), pathPtr->getFillType(), content.stream());
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  
  void SkPDFDevice::drawImageRect(const SkImage* image,
                                  const SkRect* src,
                                  const SkRect& dst,
                                  const SkPaint& paint,
                                  SkCanvas::SrcRectConstraint) {
      SkASSERT(image);
      this->internalDrawImageRect(SkKeyedImage(sk_ref_sp(const_cast<SkImage*>(image))),
                                  src, dst, paint, this->ctm());
  }
  
  void SkPDFDevice::drawBitmapRect(const SkBitmap& bm,
                                   const SkRect* src,
                                   const SkRect& dst,
                                   const SkPaint& paint,
                                   SkCanvas::SrcRectConstraint) {
      SkASSERT(!bm.drawsNothing());
      this->internalDrawImageRect(SkKeyedImage(bm), src, dst, paint, this->ctm());
  }
  
  void SkPDFDevice::drawBitmap(const SkBitmap& bm, SkScalar x, SkScalar y, const SkPaint& paint) {
      SkASSERT(!bm.drawsNothing());
      auto r = SkRect::MakeXYWH(x, y, bm.width(), bm.height());
      this->internalDrawImageRect(SkKeyedImage(bm), nullptr, r, paint, this->ctm());
  }
  
  void SkPDFDevice::drawSprite(const SkBitmap& bm, int x, int y, const SkPaint& paint) {
      SkASSERT(!bm.drawsNothing());
      auto r = SkRect::MakeXYWH(x, y, bm.width(), bm.height());
      this->internalDrawImageRect(SkKeyedImage(bm), nullptr, r, paint, SkMatrix::I());
  }
  
  void SkPDFDevice::drawImage(const SkImage* image, SkScalar x, SkScalar y, const SkPaint& paint) {
      SkASSERT(image);
      auto r = SkRect::MakeXYWH(x, y, image->width(), image->height());
      this->internalDrawImageRect(SkKeyedImage(sk_ref_sp(const_cast<SkImage*>(image))),
                                  nullptr, r, paint, this->ctm());
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  
  namespace {
  class GlyphPositioner {
  public:
      GlyphPositioner(SkDynamicMemoryWStream* content,
                      SkScalar textSkewX,
                      bool wideChars,
                      SkPoint origin)
          : fContent(content)
          , fCurrentMatrixOrigin(origin)
          , fTextSkewX(textSkewX)
          , fWideChars(wideChars) {
      }
      ~GlyphPositioner() { this->flush(); }
      void flush() {
          if (fInText) {
              fContent->writeText("> Tj\n");
              fInText = false;
          }
      }
      void writeGlyph(SkPoint xy,
                      SkScalar advanceWidth,
                      uint16_t glyph) {
          if (!fInitialized) {
              // Flip the text about the x-axis to account for origin swap and include
              // the passed parameters.
              fContent->writeText("1 0 ");
              SkPDFUtils::AppendScalar(-fTextSkewX, fContent);
              fContent->writeText(" -1 ");
              SkPDFUtils::AppendScalar(fCurrentMatrixOrigin.x(), fContent);
              fContent->writeText(" ");
              SkPDFUtils::AppendScalar(fCurrentMatrixOrigin.y(), fContent);
              fContent->writeText(" Tm\n");
              fCurrentMatrixOrigin.set(0.0f, 0.0f);
              fInitialized = true;
          }
          SkPoint position = xy - fCurrentMatrixOrigin;
          if (position != SkPoint{fXAdvance, 0}) {
              this->flush();
              SkPDFUtils::AppendScalar(position.x() - position.y() * fTextSkewX, fContent);
              fContent->writeText(" ");
              SkPDFUtils::AppendScalar(-position.y(), fContent);
              fContent->writeText(" Td ");
              fCurrentMatrixOrigin = xy;
              fXAdvance = 0;
          }
          fXAdvance += advanceWidth;
          if (!fInText) {
              fContent->writeText("<");
              fInText = true;
          }
          if (fWideChars) {
              SkPDFUtils::WriteUInt16BE(fContent, glyph);
          } else {
              SkASSERT(0 == glyph >> 8);
              SkPDFUtils::WriteUInt8(fContent, static_cast<uint8_t>(glyph));
          }
      }
  
  private:
      SkDynamicMemoryWStream* fContent;
      SkPoint fCurrentMatrixOrigin;
      SkScalar fXAdvance = 0.0f;
      SkScalar fTextSkewX;
      bool fWideChars;
      bool fInText = false;
      bool fInitialized = false;
  };
  }  // namespace
  
  static SkUnichar map_glyph(const std::vector<SkUnichar>& glyphToUnicode, SkGlyphID glyph) {
      return glyph < glyphToUnicode.size() ? glyphToUnicode[SkToInt(glyph)] : -1;
  }
  
  static void update_font(SkWStream* wStream, int fontIndex, SkScalar textSize) {
      wStream->writeText("/");
      char prefix = SkPDFResourceDict::GetResourceTypePrefix(SkPDFResourceDict::kFont_ResourceType);
      wStream->write(&prefix, 1);
      wStream->writeDecAsText(fontIndex);
      wStream->writeText(" ");
      SkPDFUtils::AppendScalar(textSize, wStream);
      wStream->writeText(" Tf\n");
  }
  
  static void draw_glyph_run_as_path(SkPDFDevice* dev, const SkGlyphRun& glyphRun, SkPoint offset) {
      SkPath path;
      SkASSERT(glyphRun.paint().getTextEncoding() == SkPaint::kGlyphID_TextEncoding);
      glyphRun.paint().getPosTextPath(glyphRun.shuntGlyphsIDs().data(),
                                      glyphRun.shuntGlyphsIDs().size() * sizeof(SkGlyphID),
                                      glyphRun.positions().data(),
                                      &path);
      path.offset(offset.x(), offset.y());
      dev->drawPath(path, glyphRun.paint(), true);
  }
  
  static bool has_outline_glyph(SkGlyphID gid, SkGlyphCache* cache) {
      const SkGlyph& glyph = cache->getGlyphIDMetrics(gid);
      const SkPath* path = cache->findPath(glyph);
      return (path && !path->isEmpty()) || (glyph.fWidth == 0 && glyph.fHeight == 0);
  }
  
  static SkRect get_glyph_bounds_device_space(SkGlyphID gid, SkGlyphCache* cache,
                                              SkScalar xScale, SkScalar yScale,
                                              SkPoint xy, const SkMatrix& ctm) {
      const SkGlyph& glyph = cache->getGlyphIDMetrics(gid);
      SkRect glyphBounds = {glyph.fLeft * xScale,
                            glyph.fTop * yScale,
                            (glyph.fLeft + glyph.fWidth) * xScale,
                            (glyph.fTop + glyph.fHeight) * yScale};
      glyphBounds.offset(xy);
      ctm.mapRect(&glyphBounds); // now in dev space.
      return glyphBounds;
  }
  
  static bool contains(const SkRect& r, SkPoint p) {
     return r.left() <= p.x() && p.x() <= r.right() &&
            r.top()  <= p.y() && p.y() <= r.bottom();
  }
  
  static sk_sp<SkImage> image_from_mask(const SkMask& mask) {
      if (!mask.fImage) {
          return nullptr;
      }
      SkIRect bounds = mask.fBounds;
      SkBitmap bm;
      switch (mask.fFormat) {
          case SkMask::kBW_Format:
              bm.allocPixels(SkImageInfo::MakeA8(bounds.width(), bounds.height()));
              for (int y = 0; y < bm.height(); ++y) {
                  for (int x8 = 0; x8 < bm.width(); x8 += 8) {
                      uint8_t v = *mask.getAddr1(x8 + bounds.x(), y + bounds.y());
                      int e = SkTMin(x8 + 8, bm.width());
                      for (int x = x8; x < e; ++x) {
                          *bm.getAddr8(x, y) = (v >> (x & 0x7)) & 0x1 ? 0xFF : 0x00;
                      }
                  }
              }
              bm.setImmutable();
              return SkImage::MakeFromBitmap(bm);
          case SkMask::kA8_Format:
              bm.installPixels(SkImageInfo::MakeA8(bounds.width(), bounds.height()),
                               mask.fImage, mask.fRowBytes);
              return SkMakeImageFromRasterBitmap(bm, kAlways_SkCopyPixelsMode);
          case SkMask::kARGB32_Format:
              bm.installPixels(SkImageInfo::MakeN32Premul(bounds.width(), bounds.height()),
                               mask.fImage, mask.fRowBytes);
              return SkMakeImageFromRasterBitmap(bm, kAlways_SkCopyPixelsMode);
          case SkMask::k3D_Format:
              SkASSERT(false);
              return nullptr;
          case SkMask::kLCD16_Format:
              SkASSERT(false);
              return nullptr;
          default:
              SkASSERT(false);
              return nullptr;
      }
  }
  
  void SkPDFDevice::internalDrawGlyphRun(const SkGlyphRun& glyphRun, SkPoint offset) {
  
      const SkGlyphID* glyphs = glyphRun.shuntGlyphsIDs().data();
      uint32_t glyphCount = SkToU32(glyphRun.shuntGlyphsIDs().size());
      const SkPaint& srcPaint = glyphRun.paint();
      if (!glyphCount || !glyphs || srcPaint.getTextSize() <= 0 || this->hasEmptyClip()) {
          return;
      }
      if (srcPaint.getPathEffect()
          || srcPaint.getMaskFilter()
          || srcPaint.isVerticalText()
          || SkPaint::kFill_Style != srcPaint.getStyle()) {
          // Stroked Text doesn't work well with Type3 fonts.
          return draw_glyph_run_as_path(this, glyphRun, offset);
      }
      SkPaint paint = calculate_text_paint(srcPaint);
      remove_color_filter(&paint);
      replace_srcmode_on_opaque_paint(&paint);
      paint.setHinting(SkPaint::kNo_Hinting);
      if (!paint.getTypeface()) {
          paint.setTypeface(SkTypeface::MakeDefault());
      }
      SkTypeface* typeface = paint.getTypeface();
      if (!typeface) {
          SkDebugf("SkPDF: SkTypeface::MakeDefault() returned nullptr.\n");
          return;
      }
      const SkAdvancedTypefaceMetrics* metrics = SkPDFFont::GetMetrics(typeface, fDocument->canon());
      if (!metrics) {
          return;
      }
      const std::vector<SkUnichar>& glyphToUnicode = SkPDFFont::GetUnicodeMap(
          typeface, fDocument->canon());
  
      SkClusterator clusterator(glyphRun);
  
      int emSize;
      auto glyphCache = SkPDFFont::MakeVectorCache(typeface, &emSize);
  
      SkScalar textSize = paint.getTextSize();
      SkScalar advanceScale = textSize * paint.getTextScaleX() / emSize;
  
      // textScaleX and textScaleY are used to get a conservative bounding box for glyphs.
      SkScalar textScaleY = textSize / emSize;
      SkScalar textScaleX = advanceScale + paint.getTextSkewX() * textScaleY;
  
      SkASSERT(paint.getTextAlign() == SkPaint::kLeft_Align);
      SkRect clipStackBounds = this->cs().bounds(this->bounds());
      struct PositionedGlyph {
          SkPoint fPos;
          SkGlyphID fGlyph;
      };
      SkTArray<PositionedGlyph> missingGlyphs;
      {
          ScopedContentEntry content(this, paint, true);
          if (!content.entry()) {
              return;
          }
          SkDynamicMemoryWStream* out = content.stream();
  
          out->writeText("BT\n");
          SK_AT_SCOPE_EXIT(out->writeText("ET\n"));
  
          const SkGlyphID maxGlyphID = SkToU16(typeface->countGlyphs() - 1);
  
          bool multiByteGlyphs = SkPDFFont::IsMultiByte(SkPDFFont::FontType(*metrics));
          if (clusterator.reversedChars()) {
              out->writeText("/ReversedChars BMC\n");
          }
          SK_AT_SCOPE_EXIT(if (clusterator.reversedChars()) { out->writeText("EMC\n"); } );
          GlyphPositioner glyphPositioner(out,
                                          paint.getTextSkewX(),
                                          multiByteGlyphs,
                                          offset);
          SkPDFFont* font = nullptr;
  
          while (SkClusterator::Cluster c = clusterator.next()) {
              int index = c.fGlyphIndex;
              int glyphLimit = index + c.fGlyphCount;
  
              bool actualText = false;
              SK_AT_SCOPE_EXIT(if (actualText) {
                                   glyphPositioner.flush();
                                   out->writeText("EMC\n");
                               });
              if (c.fUtf8Text) {  // real cluster
                  // Check if `/ActualText` needed.
                  const char* textPtr = c.fUtf8Text;
                  const char* textEnd = c.fUtf8Text + c.fTextByteLength;
                  SkUnichar unichar = SkUTF::NextUTF8(&textPtr, textEnd);
                  if (unichar < 0) {
                      return;
                  }
                  if (textPtr < textEnd ||                                  // more characters left
                      glyphLimit > index + 1 ||                             // toUnicode wouldn't work
                      unichar != map_glyph(glyphToUnicode, glyphs[index]))  // test single Unichar map
                  {
                      glyphPositioner.flush();
                      out->writeText("/Span<</ActualText <");
                      SkPDFUtils::WriteUTF16beHex(out, 0xFEFF);  // U+FEFF = BYTE ORDER MARK
                      // the BOM marks this text as UTF-16BE, not PDFDocEncoding.
                      SkPDFUtils::WriteUTF16beHex(out, unichar);  // first char
                      while (textPtr < textEnd) {
                          unichar = SkUTF::NextUTF8(&textPtr, textEnd);
                          if (unichar < 0) {
                              break;
                          }
                          SkPDFUtils::WriteUTF16beHex(out, unichar);
                      }
                      out->writeText("> >> BDC\n");  // begin marked-content sequence
                                                     // with an associated property list.
                      actualText = true;
                  }
              }
              for (; index < glyphLimit; ++index) {
                  SkGlyphID gid = glyphs[index];
                  if (gid > maxGlyphID) {
                      continue;
                  }
                  if (!font || !font->hasGlyph(gid)) {
                      // Not yet specified font or need to switch font.
                      int fontIndex = this->getFontResourceIndex(typeface, gid);
                      // All preconditions for SkPDFFont::GetFontResource are met.
                      SkASSERT(fontIndex >= 0);
                      if (fontIndex < 0) {
                          return;
                      }
                      glyphPositioner.flush();
                      update_font(out, fontIndex, textSize);
                      font = fFontResources[fontIndex];
                      SkASSERT(font);  // All preconditions for SkPDFFont::GetFontResource are met.
                      if (!font) {
                          return;
                      }
                      SkASSERT(font->multiByteGlyphs() == multiByteGlyphs);
                  }
                  SkPoint xy = glyphRun.positions()[index];
                  // Do a glyph-by-glyph bounds-reject if positions are absolute.
                  SkRect glyphBounds = get_glyph_bounds_device_space(
                          gid, glyphCache.get(), textScaleX, textScaleY,
                          xy + offset, this->ctm());
                  if (glyphBounds.isEmpty()) {
                      if (!contains(clipStackBounds, {glyphBounds.x(), glyphBounds.y()})) {
                          continue;
                      }
                  } else {
                      if (!clipStackBounds.intersects(glyphBounds)) {
                          continue;  // reject glyphs as out of bounds
                      }
                  }
                  if (!has_outline_glyph(gid, glyphCache.get())) {
                      missingGlyphs.push_back({xy + offset, gid});
                  }
  
                  font->noteGlyphUsage(gid);
  
                  SkGlyphID encodedGlyph = multiByteGlyphs ? gid : font->glyphToPDFFontEncoding(gid);
                  SkScalar advance = advanceScale * glyphCache->getGlyphIDAdvance(gid).fAdvanceX;
                  glyphPositioner.writeGlyph(xy, advance, encodedGlyph);
              }
          }
      }
      if (missingGlyphs.count() > 0) {
          // Fall back on images.
          SkPaint scaledGlyphCachePaint;
          scaledGlyphCachePaint.setTextSize(paint.getTextSize());
          scaledGlyphCachePaint.setTextScaleX(paint.getTextScaleX());
          scaledGlyphCachePaint.setTextSkewX(paint.getTextSkewX());
          scaledGlyphCachePaint.setTypeface(sk_ref_sp(typeface));
          auto scaledGlyphCache = SkStrikeCache::FindOrCreateStrikeExclusive(scaledGlyphCachePaint);
          SkTHashMap<SkPDFCanon::BitmapGlyphKey, SkPDFCanon::BitmapGlyph>* map =
              &this->getCanon()->fBitmapGlyphImages;
          for (PositionedGlyph positionedGlyph : missingGlyphs) {
              SkPDFCanon::BitmapGlyphKey key = {typeface->uniqueID(),
                                                paint.getTextSize(),
                                                paint.getTextScaleX(),
                                                paint.getTextSkewX(),
                                                positionedGlyph.fGlyph,
                                                0};
              SkImage* img = nullptr;
              SkIPoint imgOffset = {0, 0};
              if (SkPDFCanon::BitmapGlyph* ptr = map->find(key)) {
                  img = ptr->fImage.get();
                  imgOffset = ptr->fOffset;
              } else {
                  (void)scaledGlyphCache->findImage(
                          scaledGlyphCache->getGlyphIDMetrics(positionedGlyph.fGlyph));
                  SkMask mask;
                  scaledGlyphCache->getGlyphIDMetrics(positionedGlyph.fGlyph).toMask(&mask);
                  imgOffset = {mask.fBounds.x(), mask.fBounds.y()};
                  img = map->set(key, {image_from_mask(mask), imgOffset})->fImage.get();
              }
              if (img) {
                  SkPoint pt = positionedGlyph.fPos +
                               SkPoint{(SkScalar)imgOffset.x(), (SkScalar)imgOffset.y()};
                  this->drawImage(img, pt.x(), pt.y(), srcPaint);
              }
          }
      }
  }
  
  void SkPDFDevice::drawGlyphRunList(const SkGlyphRunList& glyphRunList) {
      for (const SkGlyphRun& glyphRun : glyphRunList) {
          this->internalDrawGlyphRun(glyphRun, glyphRunList.origin());
      }
  }
  
  void SkPDFDevice::drawVertices(const SkVertices*, const SkVertices::Bone[], int, SkBlendMode,
                                 const SkPaint&) {
      if (this->hasEmptyClip()) {
          return;
      }
      // TODO: implement drawVertices
  }
  
  void SkPDFDevice::drawDevice(SkBaseDevice* device, int x, int y, const SkPaint& paint) {
      SkASSERT(!paint.getImageFilter());
  
      // Check if the source device is really a bitmapdevice (because that's what we returned
      // from createDevice (likely due to an imagefilter)
      SkPixmap pmap;
      if (device->peekPixels(&pmap)) {
          SkBitmap bitmap;
          bitmap.installPixels(pmap);
          this->drawSprite(bitmap, x, y, paint);
          return;
      }
  
      // our onCreateCompatibleDevice() always creates SkPDFDevice subclasses.
      SkPDFDevice* pdfDevice = static_cast<SkPDFDevice*>(device);
  
      SkScalar scalarX = SkIntToScalar(x);
      SkScalar scalarY = SkIntToScalar(y);
      for (const RectWithData& l : pdfDevice->fLinkToURLs) {
          SkRect r = l.rect.makeOffset(scalarX, scalarY);
          fLinkToURLs.emplace_back(RectWithData{r, l.data});
      }
      for (const RectWithData& l : pdfDevice->fLinkToDestinations) {
          SkRect r = l.rect.makeOffset(scalarX, scalarY);
          fLinkToDestinations.emplace_back(RectWithData{r, l.data});
      }
      for (const NamedDestination& d : pdfDevice->fNamedDestinations) {
          SkPoint p = d.point + SkPoint::Make(scalarX, scalarY);
          fNamedDestinations.emplace_back(NamedDestination{d.nameData, p});
      }
  
      if (pdfDevice->isContentEmpty()) {
          return;
      }
  
      SkMatrix matrix = SkMatrix::MakeTrans(SkIntToScalar(x), SkIntToScalar(y));
      ScopedContentEntry content(this, this->cs(), matrix, paint);
      if (!content.entry()) {
          return;
      }
      if (content.needShape()) {
          SkPath shape;
          shape.addRect(SkRect::MakeXYWH(SkIntToScalar(x), SkIntToScalar(y),
                                         SkIntToScalar(device->width()),
                                         SkIntToScalar(device->height())));
          content.setShape(shape);
      }
      if (!content.needSource()) {
          return;
      }
  
      sk_sp<SkPDFObject> xObject = pdfDevice->makeFormXObjectFromDevice();
      SkPDFUtils::DrawFormXObject(this->addXObjectResource(xObject.get()), content.stream());
  }
  
  sk_sp<SkSurface> SkPDFDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
      return SkSurface::MakeRaster(info, &props);
  }
  
  
  sk_sp<SkPDFDict> SkPDFDevice::makeResourceDict() const {
      SkTDArray<SkPDFObject*> fonts;
      fonts.setReserve(fFontResources.count());
      for (SkPDFFont* font : fFontResources) {
          fonts.push_back(font);
      }
      return SkPDFResourceDict::Make(
              &fGraphicStateResources,
              &fShaderResources,
              &fXObjectResources,
              &fonts);
  }
  
  sk_sp<SkPDFArray> SkPDFDevice::copyMediaBox() const {
      auto mediaBox = sk_make_sp<SkPDFArray>();
      mediaBox->reserve(4);
      mediaBox->appendInt(0);
      mediaBox->appendInt(0);
      mediaBox->appendInt(fPageSize.width());
      mediaBox->appendInt(fPageSize.height());
      return mediaBox;
  }
  
  std::unique_ptr<SkStreamAsset> SkPDFDevice::content() const {
      SkDynamicMemoryWStream buffer;
      if (fInitialTransform.getType() != SkMatrix::kIdentity_Mask) {
          SkPDFUtils::AppendTransform(fInitialTransform, &buffer);
      }
  
      GraphicStackState gsState(fExistingClipStack, &buffer);
      for (const auto& entry : fContentEntries) {
          gsState.updateClip(entry.fState.fClipStack, this->bounds());
          gsState.updateMatrix(entry.fState.fMatrix);
          gsState.updateDrawingState(entry.fState);
  
          entry.fContent.writeToStream(&buffer);
      }
      gsState.drainStack();
      if (buffer.bytesWritten() > 0) {
          return std::unique_ptr<SkStreamAsset>(buffer.detachAsStream());
      } else {
          return skstd::make_unique<SkMemoryStream>();
      }
  }
  
  /* Draws an inverse filled path by using Path Ops to compute the positive
   * inverse using the current clip as the inverse bounds.
   * Return true if this was an inverse path and was properly handled,
   * otherwise returns false and the normal drawing routine should continue,
   * either as a (incorrect) fallback or because the path was not inverse
   * in the first place.
   */
  bool SkPDFDevice::handleInversePath(const SkPath& origPath,
                                      const SkPaint& paint,
                                      bool pathIsMutable) {
      if (!origPath.isInverseFillType()) {
          return false;
      }
  
      if (this->hasEmptyClip()) {
          return false;
      }
  
      SkPath modifiedPath;
      SkPath* pathPtr = const_cast<SkPath*>(&origPath);
      SkPaint noInversePaint(paint);
  
      // Merge stroking operations into final path.
      if (SkPaint::kStroke_Style == paint.getStyle() ||
          SkPaint::kStrokeAndFill_Style == paint.getStyle()) {
          bool doFillPath = paint.getFillPath(origPath, &modifiedPath);
          if (doFillPath) {
              noInversePaint.setStyle(SkPaint::kFill_Style);
              noInversePaint.setStrokeWidth(0);
              pathPtr = &modifiedPath;
          } else {
              // To be consistent with the raster output, hairline strokes
              // are rendered as non-inverted.
              modifiedPath.toggleInverseFillType();
              this->drawPath(modifiedPath, paint, true);
              return true;
          }
      }
  
      // Get bounds of clip in current transform space
      // (clip bounds are given in device space).
      SkMatrix transformInverse;
      SkMatrix totalMatrix = this->ctm();
  
      if (!totalMatrix.invert(&transformInverse)) {
          return false;
      }
      SkRect bounds = this->cs().bounds(this->bounds());
      transformInverse.mapRect(&bounds);
  
      // Extend the bounds by the line width (plus some padding)
      // so the edge doesn't cause a visible stroke.
      bounds.outset(paint.getStrokeWidth() + SK_Scalar1,
                    paint.getStrokeWidth() + SK_Scalar1);
  
      if (!calculate_inverse_path(bounds, *pathPtr, &modifiedPath)) {
          return false;
      }
  
      this->drawPath(modifiedPath, noInversePaint, true);
      return true;
  }
  
  void SkPDFDevice::appendAnnotations(SkPDFArray* array) const {
      array->reserve(fLinkToURLs.count() + fLinkToDestinations.count());
      for (const RectWithData& rectWithURL : fLinkToURLs) {
          SkRect r;
          fInitialTransform.mapRect(&r, rectWithURL.rect);
          array->appendObjRef(create_link_to_url(rectWithURL.data.get(), r));
      }
      for (const RectWithData& linkToDestination : fLinkToDestinations) {
          SkRect r;
          fInitialTransform.mapRect(&r, linkToDestination.rect);
          array->appendObjRef(
                  create_link_named_dest(linkToDestination.data.get(), r));
      }
  }
  
  void SkPDFDevice::appendDestinations(SkPDFDict* dict, SkPDFObject* page) const {
      for (const NamedDestination& dest : fNamedDestinations) {
          auto pdfDest = sk_make_sp<SkPDFArray>();
          pdfDest->reserve(5);
          pdfDest->appendObjRef(sk_ref_sp(page));
          pdfDest->appendName("XYZ");
          SkPoint p = fInitialTransform.mapXY(dest.point.x(), dest.point.y());
          pdfDest->appendScalar(p.x());
          pdfDest->appendScalar(p.y());
          pdfDest->appendInt(0);  // Leave zoom unchanged
          SkString name(static_cast<const char*>(dest.nameData->data()));
          dict->insertObject(name, std::move(pdfDest));
      }
  }
  
  sk_sp<SkPDFObject> SkPDFDevice::makeFormXObjectFromDevice(bool alpha) {
      SkMatrix inverseTransform = SkMatrix::I();
      if (!fInitialTransform.isIdentity()) {
          if (!fInitialTransform.invert(&inverseTransform)) {
              SkDEBUGFAIL("Layer initial transform should be invertible.");
              inverseTransform.reset();
          }
      }
      const char* colorSpace = alpha ? "DeviceGray" : nullptr;
      sk_sp<SkPDFObject> xobject =
          SkPDFMakeFormXObject(this->content(), this->copyMediaBox(),
                               this->makeResourceDict(), inverseTransform, colorSpace);
      // We always draw the form xobjects that we create back into the device, so
      // we simply preserve the font usage instead of pulling it out and merging
      // it back in later.
      this->cleanUp();  // Reset this device to have no content.
      this->init();
      return xobject;
  }
  
  void SkPDFDevice::drawFormXObjectWithMask(int xObjectIndex,
                                            sk_sp<SkPDFObject> mask,
                                            const SkClipStack& clipStack,
                                            SkBlendMode mode,
                                            bool invertClip) {
      if (!invertClip && clipStack.isEmpty(this->bounds())) {
          return;
      }
  
      sk_sp<SkPDFDict> sMaskGS = SkPDFGraphicState::GetSMaskGraphicState(
              std::move(mask), invertClip,
              SkPDFGraphicState::kAlpha_SMaskMode, fDocument->canon());
  
      SkPaint paint;
      paint.setBlendMode(mode);
      ScopedContentEntry content(this, clipStack, SkMatrix::I(), paint);
      if (!content.entry()) {
          return;
      }
      SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()), content.stream());
      SkPDFUtils::DrawFormXObject(xObjectIndex, content.stream());
      this->clearMaskOnGraphicState(content.stream());
  }
  
  SkPDFDevice::ContentEntry* SkPDFDevice::setUpContentEntry(const SkClipStack& clipStack,
                                                            const SkMatrix& matrix,
                                                            const SkPaint& paint,
                                                            bool hasText,
                                                            sk_sp<SkPDFObject>* dst) {
      *dst = nullptr;
      SkBlendMode blendMode = paint.getBlendMode();
  
      // For the following modes, we want to handle source and destination
      // separately, so make an object of what's already there.
      if (blendMode == SkBlendMode::kClear       ||
              blendMode == SkBlendMode::kSrc     ||
              blendMode == SkBlendMode::kSrcIn   ||
              blendMode == SkBlendMode::kDstIn   ||
              blendMode == SkBlendMode::kSrcOut  ||
              blendMode == SkBlendMode::kDstOut  ||
              blendMode == SkBlendMode::kSrcATop ||
              blendMode == SkBlendMode::kDstATop ||
              blendMode == SkBlendMode::kModulate) {
          if (!isContentEmpty()) {
              *dst = this->makeFormXObjectFromDevice();
              SkASSERT(isContentEmpty());
          } else if (blendMode != SkBlendMode::kSrc &&
                     blendMode != SkBlendMode::kSrcOut) {
              // Except for Src and SrcOut, if there isn't anything already there,
              // then we're done.
              return nullptr;
          }
      }
      // TODO(vandebo): Figure out how/if we can handle the following modes:
      // Xor, Plus.
  
      // Dst xfer mode doesn't draw source at all.
      if (blendMode == SkBlendMode::kDst) {
          return nullptr;
      }
  
      SkPDFDevice::ContentEntry* entry;
      if (fContentEntries.back() && fContentEntries.back()->fContent.bytesWritten() == 0) {
          entry = fContentEntries.back();
      } else if (blendMode != SkBlendMode::kDstOver) {
          entry = fContentEntries.emplace_back();
      } else {
          entry = fContentEntries.emplace_front();
      }
      populateGraphicStateEntryFromPaint(matrix, clipStack, paint, hasText, &entry->fState);
      return entry;
  }
  
  void SkPDFDevice::finishContentEntry(SkBlendMode blendMode,
                                       sk_sp<SkPDFObject> dst,
                                       SkPath* shape) {
      if (blendMode != SkBlendMode::kClear       &&
              blendMode != SkBlendMode::kSrc     &&
              blendMode != SkBlendMode::kDstOver &&
              blendMode != SkBlendMode::kSrcIn   &&
              blendMode != SkBlendMode::kDstIn   &&
              blendMode != SkBlendMode::kSrcOut  &&
              blendMode != SkBlendMode::kDstOut  &&
              blendMode != SkBlendMode::kSrcATop &&
              blendMode != SkBlendMode::kDstATop &&
              blendMode != SkBlendMode::kModulate) {
          SkASSERT(!dst);
          return;
      }
      if (blendMode == SkBlendMode::kDstOver) {
          SkASSERT(!dst);
          if (fContentEntries.front()->fContent.bytesWritten() == 0) {
              // For DstOver, an empty content entry was inserted before the rest
              // of the content entries. If nothing was drawn, it needs to be
              // removed.
              fContentEntries.pop_front();
          }
          return;
      }
      if (!dst) {
          SkASSERT(blendMode == SkBlendMode::kSrc ||
                   blendMode == SkBlendMode::kSrcOut);
          return;
      }
  
      SkASSERT(dst);
      SkASSERT(fContentEntries.count() == 1);
      // Changing the current content into a form-xobject will destroy the clip
      // objects which is fine since the xobject will already be clipped. However
      // if source has shape, we need to clip it too, so a copy of the clip is
      // saved.
  
      SkClipStack clipStack = fContentEntries.front()->fState.fClipStack;
  
      SkPaint stockPaint;
  
      sk_sp<SkPDFObject> srcFormXObject;
      if (isContentEmpty()) {
          // If nothing was drawn and there's no shape, then the draw was a
          // no-op, but dst needs to be restored for that to be true.
          // If there is shape, then an empty source with Src, SrcIn, SrcOut,
          // DstIn, DstAtop or Modulate reduces to Clear and DstOut or SrcAtop
          // reduces to Dst.
          if (shape == nullptr || blendMode == SkBlendMode::kDstOut ||
                  blendMode == SkBlendMode::kSrcATop) {
              ScopedContentEntry content(this, fExistingClipStack, SkMatrix::I(), stockPaint);
              // TODO: addXObjectResource take sk_sp
              SkPDFUtils::DrawFormXObject(this->addXObjectResource(dst.get()), content.stream());
              return;
          } else {
              blendMode = SkBlendMode::kClear;
          }
      } else {
          SkASSERT(fContentEntries.count() == 1);
          srcFormXObject = this->makeFormXObjectFromDevice();
      }
  
      // TODO(vandebo) srcFormXObject may contain alpha, but here we want it
      // without alpha.
      if (blendMode == SkBlendMode::kSrcATop) {
          // TODO(vandebo): In order to properly support SrcATop we have to track
          // the shape of what's been drawn at all times. It's the intersection of
          // the non-transparent parts of the device and the outlines (shape) of
          // all images and devices drawn.
          drawFormXObjectWithMask(addXObjectResource(srcFormXObject.get()), dst,
                                  fExistingClipStack, SkBlendMode::kSrcOver, true);
      } else {
          if (shape != nullptr) {
              // Draw shape into a form-xobject.
              SkPaint filledPaint;
              filledPaint.setColor(SK_ColorBLACK);
              filledPaint.setStyle(SkPaint::kFill_Style);
              this->internalDrawPath(clipStack, SkMatrix::I(), *shape, filledPaint, true);
              this->drawFormXObjectWithMask(this->addXObjectResource(dst.get()),
                                            this->makeFormXObjectFromDevice(),
                                            fExistingClipStack,
                                            SkBlendMode::kSrcOver, true);
          } else {
              this->drawFormXObjectWithMask(this->addXObjectResource(dst.get()),
                                            srcFormXObject,
                                            fExistingClipStack,
                                            SkBlendMode::kSrcOver, true);
          }
      }
  
      if (blendMode == SkBlendMode::kClear) {
          return;
      } else if (blendMode == SkBlendMode::kSrc ||
              blendMode == SkBlendMode::kDstATop) {
          ScopedContentEntry content(this, fExistingClipStack, SkMatrix::I(), stockPaint);
          if (content.entry()) {
              SkPDFUtils::DrawFormXObject(this->addXObjectResource(srcFormXObject.get()),
                                          content.stream());
          }
          if (blendMode == SkBlendMode::kSrc) {
              return;
          }
      } else if (blendMode == SkBlendMode::kSrcATop) {
          ScopedContentEntry content(this, fExistingClipStack,
                                     SkMatrix::I(), stockPaint);
          if (content.entry()) {
              SkPDFUtils::DrawFormXObject(this->addXObjectResource(dst.get()), content.stream());
          }
      }
  
      SkASSERT(blendMode == SkBlendMode::kSrcIn   ||
               blendMode == SkBlendMode::kDstIn   ||
               blendMode == SkBlendMode::kSrcOut  ||
               blendMode == SkBlendMode::kDstOut  ||
               blendMode == SkBlendMode::kSrcATop ||
               blendMode == SkBlendMode::kDstATop ||
               blendMode == SkBlendMode::kModulate);
  
      if (blendMode == SkBlendMode::kSrcIn ||
              blendMode == SkBlendMode::kSrcOut ||
              blendMode == SkBlendMode::kSrcATop) {
          drawFormXObjectWithMask(addXObjectResource(srcFormXObject.get()),
                                  std::move(dst),
                                  fExistingClipStack,
                                  SkBlendMode::kSrcOver,
                                  blendMode == SkBlendMode::kSrcOut);
          return;
      } else {
          SkBlendMode mode = SkBlendMode::kSrcOver;
          int resourceID = addXObjectResource(dst.get());
          if (blendMode == SkBlendMode::kModulate) {
              drawFormXObjectWithMask(addXObjectResource(srcFormXObject.get()),
                                      std::move(dst), fExistingClipStack,
                                      SkBlendMode::kSrcOver, false);
              mode = SkBlendMode::kMultiply;
          }
          drawFormXObjectWithMask(resourceID, std::move(srcFormXObject),
                                  fExistingClipStack, mode,
                                  blendMode == SkBlendMode::kDstOut);
          return;
      }
  }
  
  bool SkPDFDevice::isContentEmpty() {
      if (!fContentEntries.front() || fContentEntries.front()->fContent.bytesWritten() == 0) {
          SkASSERT(fContentEntries.count() <= 1);
          return true;
      }
      return false;
  }
  
  void SkPDFDevice::populateGraphicStateEntryFromPaint(
          const SkMatrix& matrix,
          const SkClipStack& clipStack,
          const SkPaint& paint,
          bool hasText,
          SkPDFDevice::GraphicStateEntry* entry) {
      NOT_IMPLEMENTED(paint.getPathEffect() != nullptr, false);
      NOT_IMPLEMENTED(paint.getMaskFilter() != nullptr, false);
      NOT_IMPLEMENTED(paint.getColorFilter() != nullptr, false);
  
      entry->fMatrix = matrix;
      entry->fClipStack = clipStack;
      entry->fColor = SkColorSetA(paint.getColor(), 0xFF);
      entry->fShaderIndex = -1;
  
      // PDF treats a shader as a color, so we only set one or the other.
      sk_sp<SkPDFObject> pdfShader;
      SkShader* shader = paint.getShader();
      SkColor color = paint.getColor();
      if (shader) {
          if (SkShader::kColor_GradientType == shader->asAGradient(nullptr)) {
              // We don't have to set a shader just for a color.
              SkShader::GradientInfo gradientInfo;
              SkColor gradientColor = SK_ColorBLACK;
              gradientInfo.fColors = &gradientColor;
              gradientInfo.fColorOffsets = nullptr;
              gradientInfo.fColorCount = 1;
              SkAssertResult(shader->asAGradient(&gradientInfo) == SkShader::kColor_GradientType);
              entry->fColor = SkColorSetA(gradientColor, 0xFF);
              color = gradientColor;
          } else {
              // PDF positions patterns relative to the initial transform, so
              // we need to apply the current transform to the shader parameters.
              SkMatrix transform = matrix;
              transform.postConcat(fInitialTransform);
  
              // PDF doesn't support kClamp_TileMode, so we simulate it by making
              // a pattern the size of the current clip.
              SkRect clipStackBounds = clipStack.bounds(this->bounds());
  
              // We need to apply the initial transform to bounds in order to get
              // bounds in a consistent coordinate system.
              fInitialTransform.mapRect(&clipStackBounds);
              SkIRect bounds;
              clipStackBounds.roundOut(&bounds);
  
              pdfShader = SkPDFMakeShader(fDocument, shader, transform, bounds, paint.getColor());
  
              if (pdfShader.get()) {
                  // pdfShader has been canonicalized so we can directly compare
                  // pointers.
                  int resourceIndex = fShaderResources.find(pdfShader.get());
                  if (resourceIndex < 0) {
                      resourceIndex = fShaderResources.count();
                      fShaderResources.push_back(pdfShader.get());
                      pdfShader.get()->ref();
                  }
                  entry->fShaderIndex = resourceIndex;
              }
          }
      }
  
      sk_sp<SkPDFDict> newGraphicState;
      if (color == paint.getColor()) {
          newGraphicState = SkPDFGraphicState::GetGraphicStateForPaint(fDocument->canon(), paint);
      } else {
          SkPaint newPaint = paint;
          newPaint.setColor(color);
          newGraphicState = SkPDFGraphicState::GetGraphicStateForPaint(fDocument->canon(), newPaint);
      }
      int resourceIndex = addGraphicStateResource(newGraphicState.get());
      entry->fGraphicStateIndex = resourceIndex;
  
      if (hasText) {
          entry->fTextScaleX = paint.getTextScaleX();
          entry->fTextFill = paint.getStyle();
      } else {
          entry->fTextScaleX = 0;
      }
  }
  
  int SkPDFDevice::addGraphicStateResource(SkPDFObject* gs) {
      // Assumes that gs has been canonicalized (so we can directly compare
      // pointers).
      int result = fGraphicStateResources.find(gs);
      if (result < 0) {
          result = fGraphicStateResources.count();
          fGraphicStateResources.push_back(gs);
          gs->ref();
      }
      return result;
  }
  
  int SkPDFDevice::addXObjectResource(SkPDFObject* xObject) {
      // TODO(halcanary): make this take a sk_sp<SkPDFObject>
      // Assumes that xobject has been canonicalized (so we can directly compare
      // pointers).
      int result = fXObjectResources.find(xObject);
      if (result < 0) {
          result = fXObjectResources.count();
          fXObjectResources.push_back(SkRef(xObject));
      }
      return result;
  }
  
  int SkPDFDevice::getFontResourceIndex(SkTypeface* typeface, uint16_t glyphID) {
      sk_sp<SkPDFFont> newFont = SkPDFFont::GetFontResource(fDocument->canon(), typeface, glyphID);
      if (!newFont) {
          return -1;
      }
      int resourceIndex = fFontResources.find(newFont.get());
      if (resourceIndex < 0) {
          fDocument->registerFont(newFont.get());
          resourceIndex = fFontResources.count();
          fFontResources.push_back(newFont.release());
      }
      return resourceIndex;
  }
  
  static SkSize rect_to_size(const SkRect& r) { return {r.width(), r.height()}; }
  
  static sk_sp<SkImage> color_filter(const SkImage* image,
                                     SkColorFilter* colorFilter) {
      auto surface =
          SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(image->dimensions()));
      SkASSERT(surface);
      SkCanvas* canvas = surface->getCanvas();
      canvas->clear(SK_ColorTRANSPARENT);
      SkPaint paint;
      paint.setColorFilter(sk_ref_sp(colorFilter));
      canvas->drawImage(image, 0, 0, &paint);
      return surface->makeImageSnapshot();
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  
  static bool is_integer(SkScalar x) {
      return x == SkScalarTruncToScalar(x);
  }
  
  static bool is_integral(const SkRect& r) {
      return is_integer(r.left()) &&
             is_integer(r.top()) &&
             is_integer(r.right()) &&
             is_integer(r.bottom());
  }
  
  void SkPDFDevice::internalDrawImageRect(SkKeyedImage imageSubset,
                                          const SkRect* src,
                                          const SkRect& dst,
                                          const SkPaint& srcPaint,
                                          const SkMatrix& ctm) {
      if (this->hasEmptyClip()) {
          return;
      }
      if (!imageSubset) {
          return;
      }
  
      // First, figure out the src->dst transform and subset the image if needed.
      SkIRect bounds = imageSubset.image()->bounds();
      SkRect srcRect = src ? *src : SkRect::Make(bounds);
      SkMatrix transform;
      transform.setRectToRect(srcRect, dst, SkMatrix::kFill_ScaleToFit);
      if (src && *src != SkRect::Make(bounds)) {
          if (!srcRect.intersect(SkRect::Make(bounds))) {
              return;
          }
          srcRect.roundOut(&bounds);
          transform.preTranslate(SkIntToScalar(bounds.x()),
                                 SkIntToScalar(bounds.y()));
          if (bounds != imageSubset.image()->bounds()) {
              imageSubset = imageSubset.subset(bounds);
          }
          if (!imageSubset) {
              return;
          }
      }
  
      // If the image is opaque and the paint's alpha is too, replace
      // kSrc blendmode with kSrcOver.
      SkPaint paint = srcPaint;
      if (imageSubset.image()->isOpaque()) {
          replace_srcmode_on_opaque_paint(&paint);
      }
  
      // Alpha-only images need to get their color from the shader, before
      // applying the colorfilter.
      if (imageSubset.image()->isAlphaOnly() && paint.getColorFilter()) {
          // must blend alpha image and shader before applying colorfilter.
          auto surface =
              SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(imageSubset.image()->dimensions()));
          SkCanvas* canvas = surface->getCanvas();
          SkPaint tmpPaint;
          // In the case of alpha images with shaders, the shader's coordinate
          // system is the image's coordiantes.
          tmpPaint.setShader(sk_ref_sp(paint.getShader()));
          tmpPaint.setColor(paint.getColor());
          canvas->clear(0x00000000);
          canvas->drawImage(imageSubset.image().get(), 0, 0, &tmpPaint);
          paint.setShader(nullptr);
          imageSubset = SkKeyedImage(surface->makeImageSnapshot());
          SkASSERT(!imageSubset.image()->isAlphaOnly());
      }
  
      if (imageSubset.image()->isAlphaOnly()) {
          // The ColorFilter applies to the paint color/shader, not the alpha layer.
          SkASSERT(nullptr == paint.getColorFilter());
  
          sk_sp<SkImage> mask = alpha_image_to_greyscale_image(imageSubset.image().get());
          if (!mask) {
              return;
          }
          // PDF doesn't seem to allow masking vector graphics with an Image XObject.
          // Must mask with a Form XObject.
          sk_sp<SkPDFDevice> maskDevice = this->makeCongruentDevice();
          {
              SkCanvas canvas(maskDevice);
              if (paint.getMaskFilter()) {
                  // This clip prevents the mask image shader from covering
                  // entire device if unnecessary.
                  canvas.clipRect(this->cs().bounds(this->bounds()));
                  canvas.concat(ctm);
                  SkPaint tmpPaint;
                  tmpPaint.setShader(mask->makeShader(&transform));
                  tmpPaint.setMaskFilter(sk_ref_sp(paint.getMaskFilter()));
                  canvas.drawRect(dst, tmpPaint);
              } else {
                  canvas.concat(ctm);
                  if (src && !is_integral(*src)) {
                      canvas.clipRect(dst);
                  }
                  canvas.concat(transform);
                  canvas.drawImage(mask, 0, 0);
              }
          }
          if (!ctm.isIdentity() && paint.getShader()) {
              transform_shader(&paint, ctm); // Since we are using identity matrix.
          }
          ScopedContentEntry content(this, this->cs(), SkMatrix::I(), paint);
          if (!content.entry()) {
              return;
          }
          this->addSMaskGraphicState(std::move(maskDevice), content.stream());
          SkPDFUtils::AppendRectangle(SkRect::Make(fPageSize), content.stream());
          SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kWinding_FillType, content.stream());
          this->clearMaskOnGraphicState(content.stream());
          return;
      }
      if (paint.getMaskFilter()) {
          paint.setShader(imageSubset.image()->makeShader(&transform));
          SkPath path;
          path.addRect(dst);  // handles non-integral clipping.
          this->internalDrawPath(this->cs(), this->ctm(), path, paint, true);
          return;
      }
      transform.postConcat(ctm);
  
      bool needToRestore = false;
      if (src && !is_integral(*src)) {
          // Need sub-pixel clipping to fix https://bug.skia.org/4374
          this->cs().save();
          this->cs().clipRect(dst, ctm, SkClipOp::kIntersect, true);
          needToRestore = true;
      }
      SK_AT_SCOPE_EXIT(if (needToRestore) { this->cs().restore(); });
  
      #ifdef SK_PDF_IMAGE_STATS
      gDrawImageCalls.fetch_add(1);
      #endif
      SkMatrix matrix = transform;
  
      // Rasterize the bitmap using perspective in a new bitmap.
      if (transform.hasPerspective()) {
          // Transform the bitmap in the new space, without taking into
          // account the initial transform.
          SkPath perspectiveOutline;
          SkRect imageBounds = SkRect::Make(imageSubset.image()->bounds());
          perspectiveOutline.addRect(imageBounds);
          perspectiveOutline.transform(transform);
  
          // TODO(edisonn): perf - use current clip too.
          // Retrieve the bounds of the new shape.
          SkRect bounds = perspectiveOutline.getBounds();
  
          // Transform the bitmap in the new space, taking into
          // account the initial transform.
          SkMatrix total = transform;
          total.postConcat(fInitialTransform);
  
          SkPath physicalPerspectiveOutline;
          physicalPerspectiveOutline.addRect(imageBounds);
          physicalPerspectiveOutline.transform(total);
  
          SkRect physicalPerspectiveBounds =
                  physicalPerspectiveOutline.getBounds();
          SkScalar scaleX = physicalPerspectiveBounds.width() / bounds.width();
          SkScalar scaleY = physicalPerspectiveBounds.height() / bounds.height();
  
          // TODO(edisonn): A better approach would be to use a bitmap shader
          // (in clamp mode) and draw a rect over the entire bounding box. Then
          // intersect perspectiveOutline to the clip. That will avoid introducing
          // alpha to the image while still giving good behavior at the edge of
          // the image.  Avoiding alpha will reduce the pdf size and generation
          // CPU time some.
  
          SkISize wh = rect_to_size(physicalPerspectiveBounds).toCeil();
  
          auto surface = SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(wh));
          if (!surface) {
              return;
          }
          SkCanvas* canvas = surface->getCanvas();
          canvas->clear(SK_ColorTRANSPARENT);
  
          SkScalar deltaX = bounds.left();
          SkScalar deltaY = bounds.top();
  
          SkMatrix offsetMatrix = transform;
          offsetMatrix.postTranslate(-deltaX, -deltaY);
          offsetMatrix.postScale(scaleX, scaleY);
  
          // Translate the draw in the new canvas, so we perfectly fit the
          // shape in the bitmap.
          canvas->setMatrix(offsetMatrix);
          canvas->drawImage(imageSubset.image(), 0, 0);
          // Make sure the final bits are in the bitmap.
          canvas->flush();
  
          // In the new space, we use the identity matrix translated
          // and scaled to reflect DPI.
          matrix.setScale(1 / scaleX, 1 / scaleY);
          matrix.postTranslate(deltaX, deltaY);
  
          imageSubset = SkKeyedImage(surface->makeImageSnapshot());
          if (!imageSubset) {
              return;
          }
      }
  
      SkMatrix scaled;
      // Adjust for origin flip.
      scaled.setScale(SK_Scalar1, -SK_Scalar1);
      scaled.postTranslate(0, SK_Scalar1);
      // Scale the image up from 1x1 to WxH.
      SkIRect subset = imageSubset.image()->bounds();
      scaled.postScale(SkIntToScalar(subset.width()),
                       SkIntToScalar(subset.height()));
      scaled.postConcat(matrix);
      ScopedContentEntry content(this, this->cs(), scaled, paint);
      if (!content.entry()) {
          return;
      }
      if (content.needShape()) {
          SkPath shape;
          shape.addRect(SkRect::Make(subset));
          shape.transform(matrix);
          content.setShape(shape);
      }
      if (!content.needSource()) {
          return;
      }
  
      if (SkColorFilter* colorFilter = paint.getColorFilter()) {
          sk_sp<SkImage> img = color_filter(imageSubset.image().get(), colorFilter);
          imageSubset = SkKeyedImage(std::move(img));
          if (!imageSubset) {
              return;
          }
          // TODO(halcanary): de-dupe this by caching filtered images.
          // (maybe in the resource cache?)
      }
  
      SkBitmapKey key = imageSubset.key();
      sk_sp<SkPDFObject>* pdfimagePtr = fDocument->canon()->fPDFBitmapMap.find(key);
      sk_sp<SkPDFObject> pdfimage = pdfimagePtr ? *pdfimagePtr : nullptr;
      if (!pdfimage) {
          SkASSERT(imageSubset);
          pdfimage = SkPDFCreateBitmapObject(imageSubset.release(),
                                             fDocument->metadata().fEncodingQuality);
          if (!pdfimage) {
              return;
          }
          fDocument->serialize(pdfimage);  // serialize images early.
          SkASSERT((key != SkBitmapKey{{0, 0, 0, 0}, 0}));
          fDocument->canon()->fPDFBitmapMap.set(key, pdfimage);
      }
      // TODO(halcanary): addXObjectResource() should take a sk_sp<SkPDFObject>
      SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()), content.stream());
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////
  
  #include "SkSpecialImage.h"
  #include "SkImageFilter.h"
  
  void SkPDFDevice::drawSpecial(SkSpecialImage* srcImg, int x, int y, const SkPaint& paint,
                                SkImage* clipImage, const SkMatrix& clipMatrix) {
      if (this->hasEmptyClip()) {
          return;
      }
      SkASSERT(!srcImg->isTextureBacked());
  
      //TODO: clipImage support
  
      SkBitmap resultBM;
  
      SkImageFilter* filter = paint.getImageFilter();
      if (filter) {
          SkIPoint offset = SkIPoint::Make(0, 0);
          SkMatrix matrix = this->ctm();
          matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
          const SkIRect clipBounds =
              this->cs().bounds(this->bounds()).roundOut().makeOffset(-x, -y);
          sk_sp<SkImageFilterCache> cache(this->getImageFilterCache());
          // TODO: Should PDF be operating in a specified color type/space? For now, run the filter
          // in the same color space as the source (this is different from all other backends).
          SkImageFilter::OutputProperties outputProperties(kN32_SkColorType, srcImg->getColorSpace());
          SkImageFilter::Context ctx(matrix, clipBounds, cache.get(), outputProperties);
  
          sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg, ctx, &offset));
          if (resultImg) {
              SkPaint tmpUnfiltered(paint);
              tmpUnfiltered.setImageFilter(nullptr);
              if (resultImg->getROPixels(&resultBM)) {
                  this->drawSprite(resultBM, x + offset.x(), y + offset.y(), tmpUnfiltered);
              }
          }
      } else {
          if (srcImg->getROPixels(&resultBM)) {
              this->drawSprite(resultBM, x, y, paint);
          }
      }
  }
  
  sk_sp<SkSpecialImage> SkPDFDevice::makeSpecial(const SkBitmap& bitmap) {
      return SkSpecialImage::MakeFromRaster(bitmap.bounds(), bitmap);
  }
  
  sk_sp<SkSpecialImage> SkPDFDevice::makeSpecial(const SkImage* image) {
      // TODO: See comment above in drawSpecial. The color mode we use for decode should be driven
      // by the destination where we're going to draw thing thing (ie this device). But we don't have
      // a color space, so we always decode in legacy mode for now.
      SkColorSpace* legacyColorSpace = nullptr;
      return SkSpecialImage::MakeFromImage(image->bounds(),
                                           image->makeNonTextureImage(), legacyColorSpace);
  }
  
  sk_sp<SkSpecialImage> SkPDFDevice::snapSpecial() {
      return nullptr;
  }
  
  SkImageFilterCache* SkPDFDevice::getImageFilterCache() {
      // We always return a transient cache, so it is freed after each
      // filter traversal.
      return SkImageFilterCache::Create(SkImageFilterCache::kDefaultTransientSize);
  }
  