Rename paint data structures

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

 /*
  * Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008-2009 Torch Mobile, Inc.
  * 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.
@@ skipping 17 matching lines @@
 #ifndef GraphicsContext_h
 #define GraphicsContext_h
 
 #include "platform/PlatformExport.h"
 #include "platform/fonts/Font.h"
 #include "platform/graphics/ColorBehavior.h"
 #include "platform/graphics/DashArray.h"
 #include "platform/graphics/DrawLooperBuilder.h"
 #include "platform/graphics/GraphicsContextState.h"
 #include "platform/graphics/ImageOrientation.h"
+#include "platform/graphics/paint/PaintRecord.h"
+#include "platform/graphics/paint/PaintRecorder.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "third_party/skia/include/core/SkClipOp.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkMetaData.h"
-#include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "wtf/Allocator.h"
 #include "wtf/Forward.h"
 #include "wtf/Noncopyable.h"
 #include <memory>
 
 class SkBitmap;
-class SkPaint;
 class SkPath;
-class SkPicture;
 class SkRRect;
 struct SkRect;
 
 namespace blink {
 
 class FloatRect;
 class FloatRoundedRect;
 class KURL;
 class PaintController;
 class Path;
@@ skipping 10 matching lines @@
   };
 
   explicit GraphicsContext(
       PaintController&,
       DisabledMode = NothingDisabled,
       SkMetaData* = 0,
       ColorBehavior = ColorBehavior::transformToGlobalTarget());
 
   ~GraphicsContext();
 
-  SkCanvas* canvas() { return m_canvas; }
-  const SkCanvas* canvas() const { return m_canvas; }
+  PaintCanvas* canvas() { return m_canvas; }
+  const PaintCanvas* canvas() const { return m_canvas; }
 
   PaintController& getPaintController() { return m_paintController; }
   const ColorBehavior& getColorBehavior() const { return m_colorBehavior; }
 
   bool contextDisabled() const { return m_disabledState; }
 
   // ---------- State management methods -----------------
   void save();
   void restore();
 
@@ skipping 81 matching lines @@
   void fillRect(const FloatRect&,
                 const Color&,
                 SkBlendMode = SkBlendMode::kSrcOver);
   void fillRoundedRect(const FloatRoundedRect&, const Color&);
   void fillDRRect(const FloatRoundedRect&,
                   const FloatRoundedRect&,
                   const Color&);
 
   void strokeRect(const FloatRect&, float lineWidth);
 
-  void drawPicture(const SkPicture*);
-  void compositePicture(sk_sp<SkPicture>,
+  void drawPicture(const PaintRecord*);
+  void compositePicture(sk_sp<PaintRecord>,
                         const FloatRect& dest,
                         const FloatRect& src,
                         SkBlendMode);
 
   void drawImage(Image*,
                  const FloatRect& destRect,
                  const FloatRect* srcRect = nullptr,
                  SkBlendMode = SkBlendMode::kSrcOver,
                  RespectImageOrientationEnum = DoNotRespectImageOrientation);
   void drawImageRRect(
@@ skipping 12 matching lines @@
                       const FloatRect& destRect,
                       const FloatRect& srcRect,
                       const FloatSize& tileScaleFactor,
                       Image::TileRule hRule = Image::StretchTile,
                       Image::TileRule vRule = Image::StretchTile,
                       SkBlendMode = SkBlendMode::kSrcOver);
 
   // These methods write to the canvas.
   // Also drawLine(const IntPoint& point1, const IntPoint& point2) and
   // fillRoundedRect().
-  void drawOval(const SkRect&, const SkPaint&);
-  void drawPath(const SkPath&, const SkPaint&);
-  void drawRect(const SkRect&, const SkPaint&);
-  void drawRRect(const SkRRect&, const SkPaint&);
+  void drawOval(const SkRect&, const PaintFlags&);
+  void drawPath(const SkPath&, const PaintFlags&);
+  void drawRect(const SkRect&, const PaintFlags&);
+  void drawRRect(const SkRRect&, const PaintFlags&);
 
   void clip(const IntRect& rect) { clipRect(rect); }
   void clip(const FloatRect& rect) { clipRect(rect); }
   void clipRoundedRect(const FloatRoundedRect&,
                        SkClipOp = SkClipOp::kIntersect,
                        AntiAliasingMode = AntiAliased);
   void clipOut(const IntRect& rect) {
     clipRect(rect, NotAntiAliased, SkClipOp::kDifference);
   }
   void clipOut(const FloatRect& rect) {
     clipRect(rect, NotAntiAliased, SkClipOp::kDifference);
   }
   void clipOut(const Path&);
   void clipOutRoundedRect(const FloatRoundedRect&);
   void clipPath(const SkPath&,
                 AntiAliasingMode = NotAntiAliased,
                 SkClipOp = SkClipOp::kIntersect);
   void clipRect(const SkRect&,
                 AntiAliasingMode = NotAntiAliased,
                 SkClipOp = SkClipOp::kIntersect);
 
   void drawText(const Font&, const TextRunPaintInfo&, const FloatPoint&);
   void drawText(const Font&,
                 const TextRunPaintInfo&,
                 const FloatPoint&,
-                const SkPaint&);
+                const PaintFlags&);
   void drawEmphasisMarks(const Font&,
                          const TextRunPaintInfo&,
                          const AtomicString& mark,
                          const FloatPoint&);
   void drawBidiText(
       const Font&,
       const TextRunPaintInfo&,
       const FloatPoint&,
       Font::CustomFontNotReadyAction = Font::DoNotPaintIfFontNotReady);
   void drawHighlightForText(const Font&,
@@ skipping 24 matching lines @@
   void endLayer();
 
   // Instead of being dispatched to the active canvas, draw commands following
   // beginRecording() are stored in a display list that can be replayed at a
   // later time. Pass in the bounding rectangle for the content in the list.
   void beginRecording(const FloatRect&);
 
   // Returns a picture with any recorded draw commands since the prerequisite
   // call to beginRecording().  The picture is guaranteed to be non-null (but
   // not necessarily non-empty), even when the context is disabled.
-  sk_sp<SkPicture> endRecording();
+  sk_sp<PaintRecord> endRecording();
 
   void setShadow(const FloatSize& offset,
                  float blur,
                  const Color&,
                  DrawLooperBuilder::ShadowTransformMode =
                      DrawLooperBuilder::ShadowRespectsTransforms,
                  DrawLooperBuilder::ShadowAlphaMode =
                      DrawLooperBuilder::ShadowRespectsAlpha,
                  ShadowMode = DrawShadowAndForeground);
 
@@ skipping 13 matching lines @@
     LeftEdge = 1 << 4
   };
   typedef unsigned Edges;
   void drawInnerShadow(const FloatRoundedRect&,
                        const Color& shadowColor,
                        const FloatSize& shadowOffset,
                        float shadowBlur,
                        float shadowSpread,
                        Edges clippedEdges = NoEdge);
 
-  const SkPaint& fillPaint() const { return immutableState()->fillPaint(); }
-  const SkPaint& strokePaint() const { return immutableState()->strokePaint(); }
+  const PaintFlags& fillPaint() const { return immutableState()->fillPaint(); }
+  const PaintFlags& strokePaint() const {
+    return immutableState()->strokePaint();
+  }
 
   // ---------- Transformation methods -----------------
   void concatCTM(const AffineTransform&);
 
   void scale(float x, float y);
   void rotate(float angleInRadians);
   void translate(float x, float y);
   // ---------- End transformation methods -----------------
 
   SkFilterQuality computeFilterQuality(Image*,
@@ skipping 45 matching lines @@
   static inline int focusRingOffset(int offset) { return offset + 2; }
 #else
   static inline int focusRingOffset(int offset) { return 0; }
   static SkPMColor lineColors(int);
   static SkPMColor antiColors1(int);
   static SkPMColor antiColors2(int);
   static void draw1xMarker(SkBitmap*, int);
   static void draw2xMarker(SkBitmap*, int);
 #endif
 
-  void saveLayer(const SkRect* bounds, const SkPaint*);
+  void saveLayer(const SkRect* bounds, const PaintFlags*);
   void restoreLayer();
 
   // Helpers for drawing a focus ring (drawFocusRing)
   void drawFocusRingPath(const SkPath&, const Color&, float width);
   void drawFocusRingRect(const SkRect&, const Color&, float width);
 
   // SkCanvas wrappers.
   void clipRRect(const SkRRect&,
                  AntiAliasingMode = NotAntiAliased,
                  SkClipOp = SkClipOp::kIntersect);
@@ skipping 19 matching lines @@
     }
   }
 
   void fillRectWithRoundedHole(const FloatRect&,
                                const FloatRoundedRect& roundedHoleRect,
                                const Color&);
 
   const SkMetaData& metaData() const { return m_metaData; }
 
   // null indicates painting is contextDisabled. Never delete this object.
-  SkCanvas* m_canvas;
+  PaintCanvas* m_canvas;
 
   PaintController& m_paintController;
 
   // Paint states stack. The state controls the appearance of drawn content, so
   // this stack enables local drawing state changes with save()/restore() calls.
   // We do not delete from this stack to avoid memory churn.
   Vector<std::unique_ptr<GraphicsContextState>> m_paintStateStack;
 
   // Current index on the stack. May not be the last thing on the stack.
   unsigned m_paintStateIndex;
 
   // Raw pointer to the current state.
   GraphicsContextState* m_paintState;
 
-  SkPictureRecorder m_pictureRecorder;
+  PaintRecorder m_pictureRecorder;
 
   SkMetaData m_metaData;
 
   const ColorBehavior m_colorBehavior;
 
 #if DCHECK_IS_ON()
   int m_layerCount;
   bool m_disableDestructionChecks;
   bool m_inDrawingRecorder;
 #endif
 
   const DisabledMode m_disabledState;
 
   float m_deviceScaleFactor;
 
   unsigned m_printing : 1;
   unsigned m_hasMetaData : 1;
 };
 
 }  // namespace blink
 
 #endif  // GraphicsContext_h