Rename paint data structures

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BaseRenderingContext2D_h
 #define BaseRenderingContext2D_h
 
 #include "bindings/modules/v8/CSSImageValueOrHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvas.h"
 #include "bindings/modules/v8/StringOrCanvasGradientOrCanvasPattern.h"
 #include "core/html/ImageData.h"
 #include "modules/ModulesExport.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPathMethods.h"
 #include "modules/canvas2d/CanvasRenderingContext2DState.h"
 #include "modules/canvas2d/CanvasStyle.h"
 #include "platform/graphics/ColorBehavior.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
-#include "third_party/skia/include/core/SkCanvas.h"
+#include "platform/graphics/paint/PaintCanvas.h"
 #include "third_party/skia/include/effects/SkComposeImageFilter.h"
 
 namespace blink {
 
 class CanvasImageSource;
 class Color;
 class Image;
 class ImageBuffer;
 class Path2D;
 class SVGMatrixTearOff;
@@ skipping 186 matching lines @@
 
   virtual int width() const = 0;
   virtual int height() const = 0;
 
   virtual bool hasImageBuffer() const = 0;
   virtual ImageBuffer* imageBuffer() const = 0;
 
   virtual bool parseColorOrCurrentColor(Color&,
                                         const String& colorString) const = 0;
 
-  virtual SkCanvas* drawingCanvas() const = 0;
-  virtual SkCanvas* existingDrawingCanvas() const = 0;
+  virtual PaintCanvas* drawingCanvas() const = 0;
+  virtual PaintCanvas* existingDrawingCanvas() const = 0;
   virtual void disableDeferral(DisableDeferralReason) = 0;
 
   virtual AffineTransform baseTransform() const = 0;
 
   virtual void didDraw(const SkIRect& dirtyRect) = 0;
 
   virtual bool stateHasFilter() = 0;
   virtual sk_sp<SkImageFilter> stateGetFilter() = 0;
   virtual void snapshotStateForFilter() = 0;
 
   virtual void validateStateStack() const = 0;
 
   virtual bool hasAlpha() const = 0;
 
   virtual bool isContextLost() const = 0;
 
   virtual ColorBehavior drawImageColorBehavior() const = 0;
 
   virtual void willDrawImage(CanvasImageSource*) const {}
 
-  void restoreMatrixClipStack(SkCanvas*) const;
+  void restoreMatrixClipStack(PaintCanvas*) const;
 
   DECLARE_VIRTUAL_TRACE();
 
   enum DrawCallType {
     StrokePath = 0,
     FillPath,
     DrawVectorImage,
     DrawBitmapImage,
     FillText,
     StrokeText,
@@ skipping 62 matching lines @@
   void inflateStrokeRect(FloatRect&) const;
 
   void unwindStateStack();
 
   enum DrawType {
     ClipFill,  // Fill that is already known to cover the current clip
     UntransformedUnclippedFill
   };
 
   void checkOverdraw(const SkRect&,
-                     const SkPaint*,
+                     const PaintFlags*,
                      CanvasRenderingContext2DState::ImageType,
                      DrawType);
 
   HeapVector<Member<CanvasRenderingContext2DState>> m_stateStack;
   AntiAliasingMode m_clipAntialiasing;
 
   void trackDrawCall(DrawCallType,
                      Path2D* path2d = nullptr,
                      int width = 0,
                      int height = 0);
 
   mutable UsageCounters m_usageCounters;
 
   float estimateRenderingCost(
       ExpensiveCanvasHeuristicParameters::RenderingModeCostIndex) const;
 
  private:
   void realizeSaves();
 
   bool shouldDrawImageAntialiased(const FloatRect& destRect) const;
 
   void drawPathInternal(const Path&,
                         CanvasRenderingContext2DState::PaintType,
                         SkPath::FillType = SkPath::kWinding_FillType);
-  void drawImageInternal(SkCanvas*,
+  void drawImageInternal(PaintCanvas*,
                          CanvasImageSource*,
                          Image*,
                          const FloatRect& srcRect,
                          const FloatRect& dstRect,
-                         const SkPaint*);
+                         const PaintFlags*);
   void clipInternal(const Path&, const String& windingRuleString);
 
   bool isPointInPathInternal(const Path&,
                              const double x,
                              const double y,
                              const String& windingRuleString);
   bool isPointInStrokeInternal(const Path&, const double x, const double y);
 
   static bool isFullCanvasCompositeMode(SkBlendMode);
 
   template <typename DrawFunc>
   void compositedDraw(const DrawFunc&,
-                      SkCanvas*,
+                      PaintCanvas*,
                       CanvasRenderingContext2DState::PaintType,
                       CanvasRenderingContext2DState::ImageType);
 
   void clearCanvas();
   bool rectContainsTransformedRect(const FloatRect&, const SkIRect&) const;
 };
 
 template <typename DrawFunc, typename ContainsFunc>
 bool BaseRenderingContext2D::draw(
     const DrawFunc& drawFunc,
@@ skipping 15 matching lines @@
     if (gradient && gradient->getGradient()->isZeroSize())
       return false;
   }
 
   if (isFullCanvasCompositeMode(state().globalComposite()) ||
       stateHasFilter()) {
     compositedDraw(drawFunc, drawingCanvas(), paintType, imageType);
     didDraw(clipBounds);
   } else if (state().globalComposite() == SkBlendMode::kSrc) {
     clearCanvas();  // takes care of checkOverdraw()
-    const SkPaint* paint =
+    const PaintFlags* paint =
         state().getPaint(paintType, DrawForegroundOnly, imageType);
     drawFunc(drawingCanvas(), paint);
     didDraw(clipBounds);
   } else {
     SkIRect dirtyRect;
     if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {
-      const SkPaint* paint =
+      const PaintFlags* paint =
           state().getPaint(paintType, DrawShadowAndForeground, imageType);
       if (paintType != CanvasRenderingContext2DState::StrokePaintType &&
           drawCoversClipBounds(clipBounds))
         checkOverdraw(bounds, paint, imageType, ClipFill);
       drawFunc(drawingCanvas(), paint);
       didDraw(dirtyRect);
     }
   }
   return true;
 }
 
 template <typename DrawFunc>
 void BaseRenderingContext2D::compositedDraw(
     const DrawFunc& drawFunc,
-    SkCanvas* c,
+    PaintCanvas* c,
     CanvasRenderingContext2DState::PaintType paintType,
     CanvasRenderingContext2DState::ImageType imageType) {
   sk_sp<SkImageFilter> filter = stateGetFilter();
   ASSERT(isFullCanvasCompositeMode(state().globalComposite()) || filter);
   SkMatrix ctm = c->getTotalMatrix();
   c->resetMatrix();
-  SkPaint compositePaint;
+  PaintFlags compositePaint;
   compositePaint.setBlendMode((SkBlendMode)state().globalComposite());
   if (state().shouldDrawShadows()) {
     // unroll into two independently composited passes if drawing shadows
-    SkPaint shadowPaint =
+    PaintFlags shadowPaint =
         *state().getPaint(paintType, DrawShadowOnly, imageType);
     int saveCount = c->getSaveCount();
     if (filter) {
-      SkPaint foregroundPaint =
+      PaintFlags foregroundPaint =
           *state().getPaint(paintType, DrawForegroundOnly, imageType);
       foregroundPaint.setImageFilter(SkComposeImageFilter::Make(
           SkComposeImageFilter::Make(foregroundPaint.refImageFilter(),
                                      shadowPaint.refImageFilter()),
           filter));
       c->setMatrix(ctm);
       drawFunc(c, &foregroundPaint);
     } else {
       ASSERT(isFullCanvasCompositeMode(state().globalComposite()));
       c->saveLayer(nullptr, &compositePaint);
       shadowPaint.setBlendMode(SkBlendMode::kSrcOver);
       c->setMatrix(ctm);
       drawFunc(c, &shadowPaint);
     }
     c->restoreToCount(saveCount);
   }
 
   compositePaint.setImageFilter(std::move(filter));
   c->saveLayer(nullptr, &compositePaint);
-  SkPaint foregroundPaint =
+  PaintFlags foregroundPaint =
       *state().getPaint(paintType, DrawForegroundOnly, imageType);
   foregroundPaint.setBlendMode(SkBlendMode::kSrcOver);
   c->setMatrix(ctm);
   drawFunc(c, &foregroundPaint);
   c->restore();
   c->setMatrix(ctm);
 }
 
 }  // namespace blink
 
 #endif  // BaseRenderingContext2D_h