Rename paint data structures

ui/gfx/canvas.h

 // Copyright (c) 2012 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 UI_GFX_CANVAS_H_
 #define UI_GFX_CANVAS_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/strings/string16.h"
-#include "skia/ext/platform_canvas.h"
-#include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkSurface.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/paint_surface.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/text_constants.h"
+
 namespace gfx {
 
 class Rect;
 class RectF;
 class FontList;
 class Point;
 class PointF;
 class Size;
 class Transform;
 class Vector2d;
 
-// Canvas is a SkCanvas wrapper that provides a number of methods for
+// Canvas is a PaintCanvas wrapper that provides a number of methods for
 // common operations used throughout an application built using ui/gfx.
 //
 // All methods that take integer arguments (as is used throughout views)
-// end with Int. If you need to use methods provided by SkCanvas, you'll
+// end with Int. If you need to use methods provided by PaintCanvas, you'll
 // need to do a conversion. In particular you'll need to use |SkIntToScalar()|,
 // or if converting from a scalar to an integer |SkScalarRound()|.
 //
 // A handful of methods in this class are overloaded providing an additional
 // argument of type SkBlendMode. SkBlendMode specifies how the
 // source and destination colors are combined. Unless otherwise specified,
 // the variant that does not take a SkBlendMode uses a transfer mode
 // of kSrcOver_Mode.
 class GFX_EXPORT Canvas {
  public:
@@ skipping 37 matching lines @@
   // Creates canvas with provided DIP |size| and |image_scale|.
   // If this canvas is not opaque, it's explicitly cleared to transparent before
   // being returned.
   Canvas(const Size& size, float image_scale, bool is_opaque);
 
   // Creates a Canvas backed by an |sk_canvas| with |image_scale_|.
   // |sk_canvas| is assumed to be already scaled based on |image_scale|
   // so no additional scaling is applied.
   // Note: the caller must ensure that sk_canvas outlives this object, or until
   // RecreateBackingCanvas is called.
-  Canvas(SkCanvas* sk_canvas, float image_scale);
+  Canvas(cc::PaintCanvas* sk_canvas, float image_scale);
 
   virtual ~Canvas();
 
   // Recreates the backing platform canvas with DIP |size| and |image_scale_|.
   // If the canvas is not opaque, it is explicitly cleared.
   // This method is public so that canvas_skia_paint can recreate the platform
   // canvas after having initialized the canvas.
   // TODO(pkotwicz): Push the image_scale into skia::PlatformCanvas such that
   // this method can be private.
   void RecreateBackingCanvas(const Size& size,
@@ skipping 148 matching lines @@
 
   // Draws a single pixel rect in the specified region with the specified
   // color and transfer mode.
   //
   // NOTE: if you need a single pixel line, use DrawLine.
   void DrawRect(const RectF& rect, SkColor color, SkBlendMode mode);
 
   // Draws the given rectangle with the given |paint| parameters.
   // DEPRECATED in favor of the RectF version below.
   // TODO(funkysidd): Remove this (http://crbug.com/553726)
-  void DrawRect(const Rect& rect, const SkPaint& paint);
+  void DrawRect(const Rect& rect, const cc::PaintFlags& paint);
 
   // Draws the given rectangle with the given |paint| parameters.
-  void DrawRect(const RectF& rect, const SkPaint& paint);
+  void DrawRect(const RectF& rect, const cc::PaintFlags& paint);
 
   // Draw the given point with the given |paint| parameters.
   // DEPRECATED in favor of the RectF version below.
   // TODO(funkysidd): Remove this (http://crbug.com/553726)
-  void DrawPoint(const Point& p, const SkPaint& paint);
+  void DrawPoint(const Point& p, const cc::PaintFlags& paint);
 
   // Draw the given point with the given |paint| parameters.
-  void DrawPoint(const PointF& p, const SkPaint& paint);
+  void DrawPoint(const PointF& p, const cc::PaintFlags& paint);
 
   // Draws a single pixel line with the specified color.
   // DEPRECATED in favor of the RectF version below.
   // TODO(funkysidd): Remove this (http://crbug.com/553726)
   void DrawLine(const Point& p1, const Point& p2, SkColor color);
 
   // Draws a single pixel line with the specified color.
   void DrawLine(const PointF& p1, const PointF& p2, SkColor color);
 
   // Draws a line with the given |paint| parameters.
   // DEPRECATED in favor of the RectF version below.
   // TODO(funkysidd): Remove this (http://crbug.com/553726)
-  void DrawLine(const Point& p1, const Point& p2, const SkPaint& paint);
+  void DrawLine(const Point& p1, const Point& p2, const cc::PaintFlags& paint);
 
   // Draws a line with the given |paint| parameters.
-  void DrawLine(const PointF& p1, const PointF& p2, const SkPaint& paint);
+  void DrawLine(const PointF& p1,
+                const PointF& p2,
+                const cc::PaintFlags& paint);
 
   // Draws a circle with the given |paint| parameters.
   // DEPRECATED in favor of the RectF version below.
   // TODO(funkysidd): Remove this (http://crbug.com/553726)
   void DrawCircle(const Point& center_point,
                   int radius,
-                  const SkPaint& paint);
+                  const cc::PaintFlags& paint);
 
   // Draws a circle with the given |paint| parameters.
   void DrawCircle(const PointF& center_point,
                   float radius,
-                  const SkPaint& paint);
+                  const cc::PaintFlags& paint);
 
   // Draws the given rectangle with rounded corners of |radius| using the
   // given |paint| parameters. DEPRECATED in favor of the RectF version below.
   // TODO(mgiuca): Remove this (http://crbug.com/553726).
-  void DrawRoundRect(const Rect& rect, int radius, const SkPaint& paint);
+  void DrawRoundRect(const Rect& rect, int radius, const cc::PaintFlags& paint);
 
   // Draws the given rectangle with rounded corners of |radius| using the
   // given |paint| parameters.
-  void DrawRoundRect(const RectF& rect, float radius, const SkPaint& paint);
+  void DrawRoundRect(const RectF& rect,
+                     float radius,
+                     const cc::PaintFlags& paint);
 
   // Draws the given path using the given |paint| parameters.
-  void DrawPath(const SkPath& path, const SkPaint& paint);
+  void DrawPath(const SkPath& path, const cc::PaintFlags& paint);
 
   // Draws an image with the origin at the specified location. The upper left
   // corner of the bitmap is rendered at the specified location.
   // Parameters are specified relative to current canvas scale not in pixels.
   // Thus, x is 2 pixels if canvas scale = 2 & |x| = 1.
   void DrawImageInt(const ImageSkia&, int x, int y);
 
   // Helper for DrawImageInt(..., paint) that constructs a temporary paint and
   // calls paint.setAlpha(alpha).
   void DrawImageInt(const ImageSkia&, int x, int y, uint8_t alpha);
 
   // Draws an image with the origin at the specified location, using the
   // specified paint. The upper left corner of the bitmap is rendered at the
   // specified location.
   // Parameters are specified relative to current canvas scale not in pixels.
   // Thus, |x| is 2 pixels if canvas scale = 2 & |x| = 1.
   void DrawImageInt(const ImageSkia& image,
                     int x,
                     int y,
-                    const SkPaint& paint);
+                    const cc::PaintFlags& paint);
 
   // Draws a portion of an image in the specified location. The src parameters
   // correspond to the region of the bitmap to draw in the region defined
   // by the dest coordinates.
   //
   // If the width or height of the source differs from that of the destination,
   // the image will be scaled. When scaling down, a mipmap will be generated.
   // Set |filter| to use filtering for images, otherwise the nearest-neighbor
   // algorithm is used for resampling.
   //
-  // An optional custom SkPaint can be provided.
+  // An optional custom cc::PaintFlags can be provided.
   // Parameters are specified relative to current canvas scale not in pixels.
   // Thus, |x| is 2 pixels if canvas scale = 2 & |x| = 1.
   void DrawImageInt(const ImageSkia& image,
                     int src_x,
                     int src_y,
                     int src_w,
                     int src_h,
                     int dest_x,
                     int dest_y,
                     int dest_w,
                     int dest_h,
                     bool filter);
   void DrawImageInt(const ImageSkia& image,
                     int src_x,
                     int src_y,
                     int src_w,
                     int src_h,
                     int dest_x,
                     int dest_y,
                     int dest_w,
                     int dest_h,
                     bool filter,
-                    const SkPaint& paint);
+                    const cc::PaintFlags& paint);
 
   // Same as the DrawImageInt functions above. Difference being this does not
   // do any scaling, i.e. it does not scale the output by the device scale
   // factor (the internal image_scale_). It takes an ImageSkiaRep instead of
   // an ImageSkia as the caller chooses the exact scale/pixel representation to
   // use, which will not be scaled while drawing it into the canvas.
   void DrawImageIntInPixel(const ImageSkiaRep& image_rep,
                            int dest_x,
                            int dest_y,
                            int dest_w,
                            int dest_h,
                            bool filter,
-                           const SkPaint& paint);
+                           const cc::PaintFlags& paint);
 
   // Draws an |image| with the top left corner at |x| and |y|, clipped to
   // |path|.
   // Parameters are specified relative to current canvas scale not in pixels.
   // Thus, x is 2 pixels if canvas scale = 2 & |x| = 1.
   void DrawImageInPath(const ImageSkia& image,
                        int x,
                        int y,
                        const SkPath& path,
-                       const SkPaint& paint);
+                       const cc::PaintFlags& paint);
 
   // Draws text with the specified color, fonts and location. The text is
   // aligned to the left, vertically centered, clipped to the region. If the
   // text is too big, it is truncated and '...' is added to the end.
   void DrawStringRect(const base::string16& text,
                       const FontList& font_list,
                       SkColor color,
                       const Rect& display_rect);
 
   // Draws text with the specified color, fonts and location. The last argument
@@ skipping 38 matching lines @@
                     float tile_scale_x,
                     float tile_scale_y,
                     int dest_x,
                     int dest_y,
                     int w,
                     int h);
 
   // Helper for TileImageInt().  Initializes |paint| for tiling |image| with the
   // given parameters.  Returns false if the provided image does not have a
   // representation for the current scale.
-  bool InitSkPaintForTiling(const ImageSkia& image,
-                            int src_x,
-                            int src_y,
-                            float tile_scale_x,
-                            float tile_scale_y,
-                            int dest_x,
-                            int dest_y,
-                            SkPaint* paint);
+  bool InitPaintFlagsForTiling(const ImageSkia& image,
+                               int src_x,
+                               int src_y,
+                               float tile_scale_x,
+                               float tile_scale_y,
+                               int dest_x,
+                               int dest_y,
+                               cc::PaintFlags* paint);
 
   // Apply transformation on the canvas.
   void Transform(const Transform& transform);
 
   // Draws the given string with a fade gradient at the end.
   void DrawFadedString(const base::string16& text,
                        const FontList& font_list,
                        SkColor color,
                        const Rect& display_rect,
                        int flags);
 
-  SkCanvas* sk_canvas() { return canvas_; }
+  // TODO(enne): rename sk_canvas members and interface.
+  cc::PaintCanvas* sk_canvas() { return canvas_; }
   float image_scale() const { return image_scale_; }
 
  private:
   // Tests whether the provided rectangle intersects the current clip rect.
   bool IntersectsClipRect(const SkRect& rect);
 
   // Helper for the DrawImageInt functions declared above. The
   // |remove_image_scale| parameter indicates if the scale of the |image_rep|
   // should be removed when drawing the image, to avoid double-scaling it.
   void DrawImageIntHelper(const ImageSkiaRep& image_rep,
                           int src_x,
                           int src_y,
                           int src_w,
                           int src_h,
                           int dest_x,
                           int dest_y,
                           int dest_w,
                           int dest_h,
                           bool filter,
-                          const SkPaint& paint,
+                          const cc::PaintFlags& paint,
                           bool remove_image_scale);
 
   // The device scale factor at which drawing on this canvas occurs.
   // An additional scale can be applied via Canvas::Scale(). However,
   // Canvas::Scale() does not affect |image_scale_|.
   float image_scale_;
 
   // canvas_ is our active canvas object. Sometimes we are also the owner,
   // in which case surface_ will be set. Other times we are just
   // borrowing someone else's canvas, in which case canvas_ will point there
   // but surface_ will be null.
-  sk_sp<SkSurface> surface_;
-  SkCanvas* canvas_;
+  sk_sp<cc::PaintSurface> surface_;
+  cc::PaintCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(Canvas);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_CANVAS_H_