Rename paint data structures

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

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 16 matching lines @@
 #include "platform/graphics/GraphicsContext.h"
 
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/FloatRoundedRect.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/ColorSpace.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/Path.h"
 #include "platform/graphics/paint/PaintController.h"
+#include "platform/graphics/paint/PaintRecord.h"
+#include "platform/graphics/paint/PaintRecorder.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/weborigin/KURL.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkData.h"
-#include "third_party/skia/include/core/SkPicture.h"
-#include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
 #include "third_party/skia/include/effects/SkPictureImageFilter.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "third_party/skia/include/utils/SkNullCanvas.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 #include <memory>
 
@@ skipping 19 matching lines @@
       m_hasMetaData(!!metaData) {
   if (metaData)
     m_metaData = *metaData;
 
   // FIXME: Do some tests to determine how many states are typically used, and
   // allocate several here.
   m_paintStateStack.push_back(GraphicsContextState::create());
   m_paintState = m_paintStateStack.back().get();
 
   if (contextDisabled()) {
-    DEFINE_STATIC_LOCAL(SkCanvas*, nullCanvas, (SkMakeNullCanvas().release()));
-    m_canvas = nullCanvas;
+    DEFINE_STATIC_LOCAL(SkCanvas*, nullSkCanvas,
+                        (SkMakeNullCanvas().release()));
+    DEFINE_STATIC_LOCAL(PaintCanvasPassThrough, nullCanvas, (nullSkCanvas));
+    m_canvas = &nullCanvas;
   }
 }
 
 GraphicsContext::~GraphicsContext() {
 #if DCHECK_IS_ON()
   if (!m_disableDestructionChecks) {
     ASSERT(!m_paintStateIndex);
     ASSERT(!m_paintState->saveCount());
     ASSERT(!m_layerCount);
     ASSERT(!saveCount());
@@ skipping 37 matching lines @@
   // (on top of its own saveCount), except for the first frame.
   unsigned count = m_paintStateIndex;
   ASSERT(m_paintStateStack.size() > m_paintStateIndex);
   for (unsigned i = 0; i <= m_paintStateIndex; ++i)
     count += m_paintStateStack[i]->saveCount();
 
   return count;
 }
 #endif
 
-void GraphicsContext::saveLayer(const SkRect* bounds, const SkPaint* paint) {
+void GraphicsContext::saveLayer(const SkRect* bounds, const PaintFlags* paint) {
   if (contextDisabled())
     return;
 
   ASSERT(m_canvas);
-
   m_canvas->saveLayer(bounds, paint);
 }
 
 void GraphicsContext::restoreLayer() {
   if (contextDisabled())
     return;
 
   ASSERT(m_canvas);
 
   m_canvas->restore();
@@ skipping 67 matching lines @@
 }
 
 void GraphicsContext::beginLayer(float opacity,
                                  SkBlendMode xfermode,
                                  const FloatRect* bounds,
                                  ColorFilter colorFilter,
                                  sk_sp<SkImageFilter> imageFilter) {
   if (contextDisabled())
     return;
 
-  SkPaint layerPaint;
+  PaintFlags layerPaint;
   layerPaint.setAlpha(static_cast<unsigned char>(opacity * 255));
   layerPaint.setBlendMode(xfermode);
   layerPaint.setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter));
   layerPaint.setImageFilter(std::move(imageFilter));
 
   if (bounds) {
     SkRect skBounds = *bounds;
     saveLayer(&skBounds, &layerPaint);
   } else {
     saveLayer(nullptr, &layerPaint);
@@ skipping 20 matching lines @@
     return;
 
   DCHECK(!m_canvas);
   m_canvas = m_pictureRecorder.beginRecording(bounds, nullptr);
   if (m_hasMetaData)
     skia::GetMetaData(*m_canvas) = m_metaData;
 }
 
 namespace {
 
-sk_sp<SkPicture> createEmptyPicture() {
-  SkPictureRecorder recorder;
+sk_sp<PaintRecord> createEmptyPicture() {
+  PaintRecorder recorder;
   recorder.beginRecording(SkRect::MakeEmpty(), nullptr);
   return recorder.finishRecordingAsPicture();
 }
 
 }  // anonymous namespace
 
-sk_sp<SkPicture> GraphicsContext::endRecording() {
+sk_sp<PaintRecord> GraphicsContext::endRecording() {
   if (contextDisabled()) {
     // Clients expect endRecording() to always return a non-null picture.
     // Cache an empty SKP to minimize overhead when disabled.
-    DEFINE_STATIC_LOCAL(sk_sp<SkPicture>, emptyPicture, (createEmptyPicture()));
+    DEFINE_STATIC_LOCAL(sk_sp<PaintRecord>, emptyPicture,
+                        (createEmptyPicture()));
     return emptyPicture;
   }
 
-  sk_sp<SkPicture> picture = m_pictureRecorder.finishRecordingAsPicture();
+  sk_sp<PaintRecord> picture = m_pictureRecorder.finishRecordingAsPicture();
   m_canvas = nullptr;
   ASSERT(picture);
   return picture;
 }
 
-void GraphicsContext::drawPicture(const SkPicture* picture) {
+void GraphicsContext::drawPicture(const PaintRecord* picture) {
   if (contextDisabled() || !picture || picture->cullRect().isEmpty())
     return;
 
   ASSERT(m_canvas);
   m_canvas->drawPicture(picture);
 }
 
-void GraphicsContext::compositePicture(sk_sp<SkPicture> picture,
+void GraphicsContext::compositePicture(sk_sp<PaintRecord> picture,
                                        const FloatRect& dest,
                                        const FloatRect& src,
                                        SkBlendMode op) {
   if (contextDisabled() || !picture)
     return;
   ASSERT(m_canvas);
 
-  SkPaint picturePaint;
+  PaintFlags picturePaint;
   picturePaint.setBlendMode(op);
   m_canvas->save();
   SkRect sourceBounds = src;
   SkRect skBounds = dest;
   SkMatrix pictureTransform;
   pictureTransform.setRectToRect(sourceBounds, skBounds,
                                  SkMatrix::kFill_ScaleToFit);
   m_canvas->concat(pictureTransform);
   picturePaint.setImageFilter(SkPictureImageFilter::MakeForLocalSpace(
-      std::move(picture), sourceBounds,
+      ToSkPicture(picture), sourceBounds,
       static_cast<SkFilterQuality>(imageInterpolationQuality())));
   m_canvas->saveLayer(&sourceBounds, &picturePaint);
   m_canvas->restore();
   m_canvas->restore();
 }
 
 void GraphicsContext::drawFocusRingPath(const SkPath& path,
                                         const Color& color,
                                         float width) {
   drawPlatformFocusRing(path, m_canvas, color.rgb(), width);
@@ skipping 137 matching lines @@
   FloatPoint p1 = point1;
   FloatPoint p2 = point2;
   bool isVerticalLine = (p1.x() == p2.x());
   int width = roundf(strokeThickness());
 
   // We know these are vertical or horizontal lines, so the length will just
   // be the sum of the displacement component vectors give or take 1 -
   // probably worth the speed up of no square root, which also won't be exact.
   FloatSize disp = p2 - p1;
   int length = SkScalarRoundToInt(disp.width() + disp.height());
-  SkPaint paint(immutableState()->strokePaint(length));
+  PaintFlags paint(immutableState()->strokePaint(length));
 
   if (getStrokeStyle() == DottedStroke || getStrokeStyle() == DashedStroke) {
     // Do a rect fill of our endpoints.  This ensures we always have the
     // appearance of being a border.  We then draw the actual dotted/dashed
     // line.
     SkRect r1, r2;
     r1.set(p1.x(), p1.y(), p1.x() + width, p1.y() + width);
     r2.set(p2.x(), p2.y(), p2.x() + width, p2.y() + width);
 
     if (isVerticalLine) {
       r1.offset(-width / 2, 0);
       r2.offset(-width / 2, -width);
     } else {
       r1.offset(0, -width / 2);
       r2.offset(-width, -width / 2);
     }
-    SkPaint fillPaint;
+    PaintFlags fillPaint;
     fillPaint.setColor(paint.getColor());
     drawRect(r1, fillPaint);
     drawRect(r2, fillPaint);
   }
 
   adjustLineToPixelBoundaries(p1, p2, width, penStyle);
   m_canvas->drawLine(p1.x(), p1.y(), p2.x(), p2.y(), paint);
 }
 
 void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& pt,
@@ skipping 108 matching lines @@
 
   // Offset it vertically by 1 so that there's some space under the text.
   SkScalar originY = WebCoreFloatToSkScalar(pt.y()) + 1;
   originX *= deviceScaleFactor;
   originY *= deviceScaleFactor;
 #endif
 
   SkMatrix localMatrix;
   localMatrix.setTranslate(originX, originY);
 
-  SkPaint paint;
-  paint.setShader(SkShader::MakeBitmapShader(
+  PaintFlags paint;
+  paint.setShader(WrapSkShader(SkShader::MakeBitmapShader(
       *misspellBitmap[index], SkShader::kRepeat_TileMode,
-      SkShader::kRepeat_TileMode, &localMatrix));
+      SkShader::kRepeat_TileMode, &localMatrix)));
 
   SkRect rect;
   rect.set(originX, originY,
            originX + WebCoreFloatToSkScalar(width) * deviceScaleFactor,
            originY + SkIntToScalar(misspellBitmap[index]->height()));
 
   if (deviceScaleFactor == 2) {
     save();
     scale(0.5, 0.5);
   }
   drawRect(rect, paint);
   if (deviceScaleFactor == 2)
     restore();
 }
 
 void GraphicsContext::drawLineForText(const FloatPoint& pt, float width) {
   if (contextDisabled())
     return;
 
   if (width <= 0)
     return;
 
-  SkPaint paint;
+  PaintFlags paint;
   switch (getStrokeStyle()) {
     case NoStroke:
     case SolidStroke:
     case DoubleStroke: {
       int thickness = SkMax32(static_cast<int>(strokeThickness()), 1);
       SkRect r;
       r.fLeft = WebCoreFloatToSkScalar(pt.x());
       // Avoid anti-aliasing lines. Currently, these are always horizontal.
       // Round to nearest pixel to match text and other content.
       r.fTop = WebCoreFloatToSkScalar(floorf(pt.y() + 0.5f));
@@ skipping 28 matching lines @@
   if (rect.isEmpty())
     return;
 
   SkRect skRect = rect;
   if (immutableState()->fillColor().alpha())
     drawRect(skRect, immutableState()->fillPaint());
 
   if (immutableState()->getStrokeData().style() != NoStroke &&
       immutableState()->strokeColor().alpha()) {
     // Stroke a width: 1 inset border
-    SkPaint paint(immutableState()->fillPaint());
+    PaintFlags paint(immutableState()->fillPaint());
     paint.setColor(strokeColor().rgb());
-    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStyle(PaintFlags::kStroke_Style);
     paint.setStrokeWidth(1);
 
     skRect.inset(0.5f, 0.5f);
     drawRect(skRect, paint);
   }
 }
 
 void GraphicsContext::drawText(const Font& font,
                                const TextRunPaintInfo& runInfo,
                                const FloatPoint& point,
-                               const SkPaint& paint) {
+                               const PaintFlags& paint) {
   if (contextDisabled())
     return;
 
   if (font.drawText(m_canvas, runInfo, point, m_deviceScaleFactor, paint))
     m_paintController.setTextPainted();
 }
 
 template <typename DrawTextFunc>
 void GraphicsContext::drawTextPasses(const DrawTextFunc& drawText) {
   TextDrawingModeFlags modeFlags = textDrawingMode();
 
   if (modeFlags & TextModeFill) {
     drawText(immutableState()->fillPaint());
   }
 
   if ((modeFlags & TextModeStroke) && getStrokeStyle() != NoStroke &&
       strokeThickness() > 0) {
-    SkPaint paintForStroking(immutableState()->strokePaint());
+    PaintFlags paintForStroking(immutableState()->strokePaint());
     if (modeFlags & TextModeFill) {
       paintForStroking.setLooper(
           0);  // shadow was already applied during fill pass
     }
     drawText(paintForStroking);
   }
 }
 
 void GraphicsContext::drawText(const Font& font,
                                const TextRunPaintInfo& runInfo,
                                const FloatPoint& point) {
   if (contextDisabled())
     return;
 
-  drawTextPasses([&font, &runInfo, &point, this](const SkPaint& paint) {
+  drawTextPasses([&font, &runInfo, &point, this](const PaintFlags& paint) {
     if (font.drawText(m_canvas, runInfo, point, m_deviceScaleFactor, paint))
       m_paintController.setTextPainted();
   });
 }
 
 void GraphicsContext::drawEmphasisMarks(const Font& font,
                                         const TextRunPaintInfo& runInfo,
                                         const AtomicString& mark,
                                         const FloatPoint& point) {
   if (contextDisabled())
     return;
 
-  drawTextPasses([&font, &runInfo, &mark, &point, this](const SkPaint& paint) {
+  drawTextPasses([&font, &runInfo, &mark, &point,
+                  this](const PaintFlags& paint) {
     font.drawEmphasisMarks(m_canvas, runInfo, mark, point, m_deviceScaleFactor,
                            paint);
   });
 }
 
 void GraphicsContext::drawBidiText(
     const Font& font,
     const TextRunPaintInfo& runInfo,
     const FloatPoint& point,
     Font::CustomFontNotReadyAction customFontNotReadyAction) {
   if (contextDisabled())
     return;
 
   drawTextPasses([&font, &runInfo, &point, customFontNotReadyAction,
-                  this](const SkPaint& paint) {
+                  this](const PaintFlags& paint) {
     if (font.drawBidiText(m_canvas, runInfo, point, customFontNotReadyAction,
                           m_deviceScaleFactor, paint))
       m_paintController.setTextPainted();
   });
 }
 
 void GraphicsContext::drawHighlightForText(const Font& font,
                                            const TextRun& run,
                                            const FloatPoint& point,
                                            int h,
@@ skipping 10 matching lines @@
     Image* image,
     const FloatRect& dest,
     const FloatRect* srcPtr,
     SkBlendMode op,
     RespectImageOrientationEnum shouldRespectImageOrientation) {
   if (contextDisabled() || !image)
     return;
 
   const FloatRect src = srcPtr ? *srcPtr : image->rect();
 
-  SkPaint imagePaint = immutableState()->fillPaint();
+  PaintFlags imagePaint = immutableState()->fillPaint();
   imagePaint.setBlendMode(op);
   imagePaint.setColor(SK_ColorBLACK);
   imagePaint.setFilterQuality(computeFilterQuality(image, dest, src));
   imagePaint.setAntiAlias(shouldAntialias());
   image->draw(m_canvas, imagePaint, dest, src, shouldRespectImageOrientation,
               Image::ClampImageToSourceRect, m_colorBehavior);
   m_paintController.setImagePainted();
 }
 
 void GraphicsContext::drawImageRRect(
     Image* image,
     const FloatRoundedRect& dest,
     const FloatRect& srcRect,
     SkBlendMode op,
     RespectImageOrientationEnum respectOrientation) {
   if (contextDisabled() || !image)
     return;
 
   if (!dest.isRounded()) {
     drawImage(image, dest.rect(), &srcRect, op, respectOrientation);
     return;
   }
 
   DCHECK(dest.isRenderable());
 
   const FloatRect visibleSrc = intersection(srcRect, image->rect());
   if (dest.isEmpty() || visibleSrc.isEmpty())
     return;
 
-  SkPaint imagePaint = immutableState()->fillPaint();
+  PaintFlags imagePaint = immutableState()->fillPaint();
   imagePaint.setBlendMode(op);
   imagePaint.setColor(SK_ColorBLACK);
   imagePaint.setFilterQuality(
       computeFilterQuality(image, dest.rect(), srcRect));
   imagePaint.setAntiAlias(shouldAntialias());
 
   bool useShader = (visibleSrc == srcRect) &&
                    (respectOrientation == DoNotRespectImageOrientation);
   if (useShader) {
     const SkMatrix localMatrix = SkMatrix::MakeRectToRect(
         visibleSrc, dest.rect(), SkMatrix::kFill_ScaleToFit);
     useShader = image->applyShader(imagePaint, localMatrix, m_colorBehavior);
   }
 
   if (useShader) {
     // Shader-based fast path.
     m_canvas->drawRRect(dest, imagePaint);
   } else {
     // Clip-based fallback.
-    SkAutoCanvasRestore autoRestore(m_canvas, true);
+    PaintCanvasAutoRestore autoRestore(m_canvas, true);
     m_canvas->clipRRect(dest, imagePaint.isAntiAlias());
     image->draw(m_canvas, imagePaint, dest.rect(), srcRect, respectOrientation,
                 Image::ClampImageToSourceRect, m_colorBehavior);
   }
 
   m_paintController.setImagePainted();
 }
 
 SkFilterQuality GraphicsContext::computeFilterQuality(
     Image* image,
@@ skipping 48 matching lines @@
     // Just do a scale.
     drawImage(image, dest, &srcRect, op);
     return;
   }
 
   image->drawTiledBorder(*this, dest, srcRect, tileScaleFactor, hRule, vRule,
                          op);
   m_paintController.setImagePainted();
 }
 
-void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint) {
+void GraphicsContext::drawOval(const SkRect& oval, const PaintFlags& paint) {
   if (contextDisabled())
     return;
   ASSERT(m_canvas);
 
   m_canvas->drawOval(oval, paint);
 }
 
-void GraphicsContext::drawPath(const SkPath& path, const SkPaint& paint) {
+void GraphicsContext::drawPath(const SkPath& path, const PaintFlags& paint) {
   if (contextDisabled())
     return;
   ASSERT(m_canvas);
 
   m_canvas->drawPath(path, paint);
 }
 
-void GraphicsContext::drawRect(const SkRect& rect, const SkPaint& paint) {
+void GraphicsContext::drawRect(const SkRect& rect, const PaintFlags& paint) {
   if (contextDisabled())
     return;
   ASSERT(m_canvas);
 
   m_canvas->drawRect(rect, paint);
 }
 
-void GraphicsContext::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
+void GraphicsContext::drawRRect(const SkRRect& rrect, const PaintFlags& paint) {
   if (contextDisabled())
     return;
   ASSERT(m_canvas);
 
   m_canvas->drawRRect(rrect, paint);
 }
 
 void GraphicsContext::fillPath(const Path& pathToFill) {
   if (contextDisabled() || pathToFill.isEmpty())
     return;
 
   drawPath(pathToFill.getSkPath(), immutableState()->fillPaint());
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect) {
   if (contextDisabled())
     return;
 
   drawRect(rect, immutableState()->fillPaint());
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect,
                                const Color& color,
                                SkBlendMode xferMode) {
   if (contextDisabled())
     return;
 
-  SkPaint paint = immutableState()->fillPaint();
+  PaintFlags paint = immutableState()->fillPaint();
   paint.setColor(color.rgb());
   paint.setBlendMode(xferMode);
 
   drawRect(rect, paint);
 }
 
 void GraphicsContext::fillRoundedRect(const FloatRoundedRect& rrect,
                                       const Color& color) {
   if (contextDisabled())
     return;
 
   if (!rrect.isRounded() || !rrect.isRenderable()) {
     fillRect(rrect.rect(), color);
     return;
   }
 
   if (color == fillColor()) {
     drawRRect(rrect, immutableState()->fillPaint());
     return;
   }
 
-  SkPaint paint = immutableState()->fillPaint();
+  PaintFlags paint = immutableState()->fillPaint();
   paint.setColor(color.rgb());
 
   drawRRect(rrect, paint);
 }
 
 namespace {
 
 bool isSimpleDRRect(const FloatRoundedRect& outer,
                     const FloatRoundedRect& inner) {
   // A DRRect is "simple" (i.e. can be drawn as a rrect stroke) if
@@ skipping 50 matching lines @@
                                  const FloatRoundedRect& inner,
                                  const Color& color) {
   if (contextDisabled())
     return;
   ASSERT(m_canvas);
 
   if (!isSimpleDRRect(outer, inner)) {
     if (color == fillColor()) {
       m_canvas->drawDRRect(outer, inner, immutableState()->fillPaint());
     } else {
-      SkPaint paint(immutableState()->fillPaint());
+      PaintFlags paint(immutableState()->fillPaint());
       paint.setColor(color.rgb());
       m_canvas->drawDRRect(outer, inner, paint);
     }
 
     return;
   }
 
   // We can draw this as a stroked rrect.
   float strokeWidth = inner.rect().x() - outer.rect().x();
   SkRRect strokeRRect = outer;
   strokeRRect.inset(strokeWidth / 2, strokeWidth / 2);
 
-  SkPaint strokePaint(immutableState()->fillPaint());
+  PaintFlags strokePaint(immutableState()->fillPaint());
   strokePaint.setColor(color.rgb());
-  strokePaint.setStyle(SkPaint::kStroke_Style);
+  strokePaint.setStyle(PaintFlags::kStroke_Style);
   strokePaint.setStrokeWidth(strokeWidth);
 
   m_canvas->drawRRect(strokeRRect, strokePaint);
 }
 
 void GraphicsContext::fillEllipse(const FloatRect& ellipse) {
   if (contextDisabled())
     return;
 
   drawOval(ellipse, immutableState()->fillPaint());
 }
 
 void GraphicsContext::strokePath(const Path& pathToStroke) {
   if (contextDisabled() || pathToStroke.isEmpty())
     return;
 
   drawPath(pathToStroke.getSkPath(), immutableState()->strokePaint());
 }
 
 void GraphicsContext::strokeRect(const FloatRect& rect, float lineWidth) {
   if (contextDisabled())
     return;
 
-  SkPaint paint(immutableState()->strokePaint());
+  PaintFlags paint(immutableState()->strokePaint());
   paint.setStrokeWidth(WebCoreFloatToSkScalar(lineWidth));
   // Reset the dash effect to account for the width
   immutableState()->getStrokeData().setupPaintDashPathEffect(&paint, 0);
   // strokerect has special rules for CSS when the rect is degenerate:
   // if width==0 && height==0, do nothing
   // if width==0 || height==0, then just draw line for the other dimension
   SkRect r(rect);
   bool validW = r.width() > 0;
   bool validH = r.height() > 0;
   if (validW && validH) {
@@ skipping 141 matching lines @@
   concat(affineTransformToSkMatrix(affine));
 }
 
 void GraphicsContext::fillRectWithRoundedHole(
     const FloatRect& rect,
     const FloatRoundedRect& roundedHoleRect,
     const Color& color) {
   if (contextDisabled())
     return;
 
-  SkPaint paint(immutableState()->fillPaint());
+  PaintFlags paint(immutableState()->fillPaint());
   paint.setColor(color.rgb());
   m_canvas->drawDRRect(SkRRect::MakeRect(rect), roundedHoleRect, paint);
 }
 
 void GraphicsContext::adjustLineToPixelBoundaries(FloatPoint& p1,
                                                   FloatPoint& p2,
                                                   float strokeWidth,
                                                   StrokeStyle penStyle) {
   // For odd widths, we add in 0.5 to the appropriate x/y so that the float
   // arithmetic works out.  For example, with a border width of 3, WebKit will
@@ skipping 129 matching lines @@
   static const SkPMColor colors[] = {
       SkPreMultiplyARGB(0x60, 0xFF, 0x00, 0x00),  // More transparent red
       SkPreMultiplyARGB(0x60, 0xC0, 0xC0, 0xC0)   // More transparent gray
   };
 
   return colors[index];
 }
 #endif
 
 }  // namespace blink