Make cc/paint have concrete types

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 64 matching lines @@
     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*, nullSkCanvas,
                         (SkMakeNullCanvas().release()));
-    DEFINE_STATIC_LOCAL(PaintCanvasPassThrough, nullCanvas, (nullSkCanvas));
+    DEFINE_STATIC_LOCAL(PaintCanvas, nullCanvas, (nullSkCanvas));
     m_canvas = &nullCanvas;
   }
 }
 
 GraphicsContext::~GraphicsContext() {
 #if DCHECK_IS_ON()
   if (!m_disableDestructionChecks) {
     DCHECK(!m_paintStateIndex);
     DCHECK(!m_paintState->saveCount());
     DCHECK(!m_layerCount);
@@ skipping 164 matching lines @@
 #if DCHECK_IS_ON()
   DCHECK_GT(m_layerCount--, 0);
 #endif
 }
 
 void GraphicsContext::beginRecording(const FloatRect& bounds) {
   if (contextDisabled())
     return;
 
   DCHECK(!m_canvas);
-  m_canvas = m_paintRecorder.beginRecording(bounds, nullptr);
+  m_canvas = m_paintRecorder.beginRecording(bounds);
   if (m_hasMetaData)
     m_canvas->getMetaData() = m_metaData;
 }
 
 namespace {
 
 sk_sp<PaintRecord> createEmptyPaintRecord() {
   PaintRecorder recorder;
-  recorder.beginRecording(SkRect::MakeEmpty(), nullptr);
+  recorder.beginRecording(SkRect::MakeEmpty());
   return recorder.finishRecordingAsPicture();
 }
 
 }  // anonymous namespace
 
 sk_sp<PaintRecord> GraphicsContext::endRecording() {
   if (contextDisabled()) {
     // Clients expect endRecording() to always return a non-null paint record.
     // Cache an empty one to minimize overhead when disabled.
     DEFINE_STATIC_LOCAL(sk_sp<PaintRecord>, emptyPaintRecord,
@@ skipping 274 matching lines @@
   path.cubicTo(kW * 3 / 8, kH * 1 / 4,
                kW * 3 / 8, kH * 3 / 4,
                kW * 5 / 8, kH * 3 / 4);
   path.cubicTo(kW * 7 / 8, kH * 3 / 4,
                kW * 7 / 8, kH * 1 / 4,
                kW * 9 / 8, kH * 1 / 4);
 
   PaintFlags flags;
   flags.setAntiAlias(true);
   flags.setColor(color);
-  flags.setStyle(SkPaint::kStroke_Style);
+  flags.setStyle(PaintFlags::kStroke_Style);
   flags.setStrokeWidth(kH * 1 / 2);
 
   PaintRecorder recorder;
   recorder.beginRecording(kW, kH);
   recorder.getRecordingCanvas()->drawPath(path, flags);
 
   return recorder.finishRecordingAsPicture();
 }
 
 #else  // OS(MACOSX)
@@ skipping 64 matching lines @@
 #else
   // Offset it vertically by 1 so that there's some space under the text.
   originY += 1;
 #endif
 
   const auto rect = SkRect::MakeWH(width, marker->cullRect().height() * zoom);
   const auto localMatrix = SkMatrix::MakeScale(zoom, zoom);
 
   PaintFlags flags;
   flags.setAntiAlias(true);
-  flags.setShader(WrapSkShader(SkShader::MakePictureShader(
-      sk_ref_sp(marker), SkShader::kRepeat_TileMode, SkShader::kClamp_TileMode,
-      &localMatrix, nullptr)));
+  flags.setShader(WrapSkShader(
+      MakePaintShaderRecord(sk_ref_sp(marker), SkShader::kRepeat_TileMode,
+                            SkShader::kClamp_TileMode, &localMatrix, nullptr)));
 
   // Apply the origin translation as a global transform.  This ensures that the
   // shader local matrix depends solely on zoom => Skia can reuse the same
   // cached tile for all markers at a given zoom level.
   PaintCanvasAutoRestore acr(m_canvas, true);
   m_canvas->translate(originX, originY);
   m_canvas->drawRect(rect, flags);
 }
 
 void GraphicsContext::drawLineForText(const FloatPoint& pt, float width) {
@@ skipping 581 matching lines @@
 
   m_canvas->scale(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
 }
 
 void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect) {
   if (contextDisabled())
     return;
   DCHECK(m_canvas);
 
   sk_sp<SkData> url(SkData::MakeWithCString(link.getString().utf8().data()));
-  SkAnnotateRectWithURL(m_canvas, destRect, url.get());
+  PaintCanvasAnnotateRectWithURL(m_canvas, destRect, url.get());
 }
 
 void GraphicsContext::setURLFragmentForRect(const String& destName,
                                             const IntRect& rect) {
   if (contextDisabled())
     return;
   DCHECK(m_canvas);
 
   sk_sp<SkData> skDestName(SkData::MakeWithCString(destName.utf8().data()));
-  SkAnnotateLinkToDestination(m_canvas, rect, skDestName.get());
+  PaintCanvasAnnotateLinkToDestination(m_canvas, rect, skDestName.get());
 }
 
 void GraphicsContext::setURLDestinationLocation(const String& name,
                                                 const IntPoint& location) {
   if (contextDisabled())
     return;
   DCHECK(m_canvas);
 
   sk_sp<SkData> skName(SkData::MakeWithCString(name.utf8().data()));
-  SkAnnotateNamedDestination(
+  PaintCanvasAnnotateNamedDestination(
       m_canvas, SkPoint::Make(location.x(), location.y()), skName.get());
 }
 
 void GraphicsContext::concatCTM(const AffineTransform& affine) {
   concat(affineTransformToSkMatrix(affine));
 }
 
 void GraphicsContext::fillRectWithRoundedHole(
     const FloatRect& rect,
     const FloatRoundedRect& roundedHoleRect,
@@ skipping 53 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
 
   return nullptr;
 }
 
 }  // namespace blink