Rename paint data structures

ui/gfx/canvas.cc

 // 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.
 
 #include "ui/gfx/canvas.h"
 
 #include <cmath>
 #include <limits>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/paint_shader.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
-#include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/geometry/insets_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_paint_util.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 
 namespace {
 
-sk_sp<SkSurface> CreateSurface(const Size& size, bool is_opaque) {
+sk_sp<cc::PaintSurface> CreateSurface(const Size& size, bool is_opaque) {
   // SkSurface cannot be zero-sized, but clients of Canvas sometimes request
   // that (and then later resize).
   int width = std::max(size.width(), 1);
   int height = std::max(size.height(), 1);
   SkAlphaType alpha = is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
   SkImageInfo info = SkImageInfo::MakeN32(width, height, alpha);
-  return SkSurface::MakeRaster(info);
+  return cc::PaintSurface::MakeRaster(info);
 }
 
 }  // namespace
 
 Canvas::Canvas(const Size& size, float image_scale, bool is_opaque)
     : image_scale_(image_scale) {
   Size pixel_size = ScaleToCeiledSize(size, image_scale);
   surface_ = CreateSurface(pixel_size, is_opaque);
   canvas_ = surface_->getCanvas();
 
 #if !defined(USE_CAIRO)
   // skia::PlatformCanvas instances are initialized to 0 by Cairo, but
   // uninitialized on other platforms.
   if (!is_opaque)
     canvas_->clear(SkColorSetARGB(0, 0, 0, 0));
 #endif
 
   SkScalar scale_scalar = SkFloatToScalar(image_scale);
   canvas_->scale(scale_scalar, scale_scalar);
 }
 
 Canvas::Canvas()
     : image_scale_(1.f),
       surface_(CreateSurface({0, 0}, false)),
       canvas_(surface_->getCanvas()) {}
 
-Canvas::Canvas(SkCanvas* canvas, float image_scale)
+Canvas::Canvas(cc::PaintCanvas* canvas, float image_scale)
     : image_scale_(image_scale), canvas_(canvas) {
   DCHECK(canvas_);
 }
 
 Canvas::~Canvas() {
 }
 
 void Canvas::RecreateBackingCanvas(const Size& size,
                                    float image_scale,
                                    bool is_opaque) {
@@ skipping 81 matching lines @@
     for (int i = 0; i < row_pixels; i++) {
       for (int u = 0; u < col_pixels; u++) {
         if ((u % 2 + i % 2) % 2 != 0) {
           dot[i * row_pixels + u] = color;
         }
       }
     }
   }
 
   // Make a shader for the bitmap with an origin of the box we'll draw.
-  SkPaint paint;
-  paint.setShader(SkShader::MakeBitmapShader(*dots, SkShader::kRepeat_TileMode,
-                                             SkShader::kRepeat_TileMode));
+  cc::PaintFlags paint;
+  paint.setShader(cc::WrapSkShader(SkShader::MakeBitmapShader(
+      *dots, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode)));
 
   DrawRect(RectF(rect.x(), rect.y(), rect.width(), 1), paint);
   DrawRect(RectF(rect.x(), rect.y() + rect.height() - 1, rect.width(), 1),
            paint);
   DrawRect(RectF(rect.x(), rect.y(), 1, rect.height()), paint);
   DrawRect(RectF(rect.x() + rect.width() - 1, rect.y(), 1, rect.height()),
            paint);
 }
 
 float Canvas::UndoDeviceScaleFactor() {
@@ skipping 59 matching lines @@
 
 void Canvas::DrawColor(SkColor color, SkBlendMode mode) {
   canvas_->drawColor(color, mode);
 }
 
 void Canvas::FillRect(const Rect& rect, SkColor color) {
   FillRect(rect, color, SkBlendMode::kSrcOver);
 }
 
 void Canvas::FillRect(const Rect& rect, SkColor color, SkBlendMode mode) {
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(color);
-  paint.setStyle(SkPaint::kFill_Style);
+  paint.setStyle(cc::PaintFlags::kFill_Style);
   paint.setBlendMode(mode);
   DrawRect(rect, paint);
 }
 
 void Canvas::DrawRect(const Rect& rect, SkColor color) {
   DrawRect(RectF(rect), color);
 }
 
 void Canvas::DrawRect(const RectF& rect, SkColor color) {
   DrawRect(rect, color, SkBlendMode::kSrcOver);
 }
 
 void Canvas::DrawRect(const Rect& rect, SkColor color, SkBlendMode mode) {
   DrawRect(RectF(rect), color, mode);
 }
 
 void Canvas::DrawRect(const RectF& rect, SkColor color, SkBlendMode mode) {
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(color);
-  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setStyle(cc::PaintFlags::kStroke_Style);
   // Set a stroke width of 0, which will put us down the stroke rect path.  If
   // we set a stroke width of 1, for example, this will internally create a
   // path and fill it, which causes problems near the edge of the canvas.
   paint.setStrokeWidth(SkIntToScalar(0));
   paint.setBlendMode(mode);
 
   DrawRect(rect, paint);
 }
 
-void Canvas::DrawRect(const Rect& rect, const SkPaint& paint) {
+void Canvas::DrawRect(const Rect& rect, const cc::PaintFlags& paint) {
   DrawRect(RectF(rect), paint);
 }
 
-void Canvas::DrawRect(const RectF& rect, const SkPaint& paint) {
+void Canvas::DrawRect(const RectF& rect, const cc::PaintFlags& paint) {
   canvas_->drawRect(RectFToSkRect(rect), paint);
 }
 
-void Canvas::DrawPoint(const Point& p1, const SkPaint& paint) {
+void Canvas::DrawPoint(const Point& p1, const cc::PaintFlags& paint) {
   DrawPoint(PointF(p1), paint);
 }
 
-void Canvas::DrawPoint(const PointF& p1, const SkPaint& paint) {
+void Canvas::DrawPoint(const PointF& p1, const cc::PaintFlags& paint) {
   canvas_->drawPoint(SkFloatToScalar(p1.x()), SkFloatToScalar(p1.y()), paint);
 }
 
 void Canvas::DrawLine(const Point& p1, const Point& p2, SkColor color) {
   DrawLine(PointF(p1), PointF(p2), color);
 }
 
 void Canvas::DrawLine(const PointF& p1, const PointF& p2, SkColor color) {
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(color);
   paint.setStrokeWidth(SkIntToScalar(1));
   DrawLine(p1, p2, paint);
 }
 
-void Canvas::DrawLine(const Point& p1, const Point& p2, const SkPaint& paint) {
+void Canvas::DrawLine(const Point& p1,
+                      const Point& p2,
+                      const cc::PaintFlags& paint) {
   DrawLine(PointF(p1), PointF(p2), paint);
 }
 
 void Canvas::DrawLine(const PointF& p1,
                       const PointF& p2,
-                      const SkPaint& paint) {
+                      const cc::PaintFlags& paint) {
   canvas_->drawLine(SkFloatToScalar(p1.x()), SkFloatToScalar(p1.y()),
                     SkFloatToScalar(p2.x()), SkFloatToScalar(p2.y()), paint);
 }
 
 void Canvas::DrawCircle(const Point& center_point,
                         int radius,
-                        const SkPaint& paint) {
+                        const cc::PaintFlags& paint) {
   DrawCircle(PointF(center_point), radius, paint);
 }
 
 void Canvas::DrawCircle(const PointF& center_point,
                         float radius,
-                        const SkPaint& paint) {
+                        const cc::PaintFlags& paint) {
   canvas_->drawCircle(SkFloatToScalar(center_point.x()),
                       SkFloatToScalar(center_point.y()),
                       SkFloatToScalar(radius), paint);
 }
 
 void Canvas::DrawRoundRect(const Rect& rect,
                            int radius,
-                           const SkPaint& paint) {
+                           const cc::PaintFlags& paint) {
   DrawRoundRect(RectF(rect), radius, paint);
 }
 
 void Canvas::DrawRoundRect(const RectF& rect,
                            float radius,
-                           const SkPaint& paint) {
+                           const cc::PaintFlags& paint) {
   canvas_->drawRoundRect(RectFToSkRect(rect), SkFloatToScalar(radius),
                          SkFloatToScalar(radius), paint);
 }
 
-void Canvas::DrawPath(const SkPath& path, const SkPaint& paint) {
+void Canvas::DrawPath(const SkPath& path, const cc::PaintFlags& paint) {
   canvas_->drawPath(path, paint);
 }
 
 void Canvas::DrawFocusRect(const Rect& rect) {
   DrawFocusRect(RectF(rect));
 }
 
 void Canvas::DrawFocusRect(const RectF& rect) {
   DrawDashedRect(rect, SK_ColorGRAY);
 }
 
 void Canvas::DrawSolidFocusRect(const RectF& rect,
                                 SkColor color,
                                 float thickness) {
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(color);
   paint.setStrokeWidth(SkFloatToScalar(thickness));
-  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setStyle(cc::PaintFlags::kStroke_Style);
   gfx::RectF draw_rect = rect;
   draw_rect.Inset(gfx::InsetsF(thickness / 2));
   DrawRect(draw_rect, paint);
 }
 
 void Canvas::DrawImageInt(const ImageSkia& image, int x, int y) {
-  SkPaint paint;
+  cc::PaintFlags paint;
   DrawImageInt(image, x, y, paint);
 }
 
 void Canvas::DrawImageInt(const ImageSkia& image, int x, int y, uint8_t a) {
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setAlpha(a);
   DrawImageInt(image, x, y, paint);
 }
 
 void Canvas::DrawImageInt(const ImageSkia& image,
                           int x,
                           int y,
-                          const SkPaint& paint) {
+                          const cc::PaintFlags& paint) {
   const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return;
   const SkBitmap& bitmap = image_rep.sk_bitmap();
   float bitmap_scale = image_rep.scale();
 
   ScopedCanvas scoper(this);
   canvas_->scale(SkFloatToScalar(1.0f / bitmap_scale),
                  SkFloatToScalar(1.0f / bitmap_scale));
   canvas_->drawBitmap(bitmap,
                       SkFloatToScalar(x * bitmap_scale),
                       SkFloatToScalar(y * bitmap_scale),
                       &paint);
 }
 
 void Canvas::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) {
-  SkPaint p;
+  cc::PaintFlags p;
   DrawImageInt(image, src_x, src_y, src_w, src_h, dest_x, dest_y,
                dest_w, dest_h, filter, p);
 }
 
 void Canvas::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) {
   const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return;
   bool remove_image_scale = true;
   DrawImageIntHelper(image_rep, src_x, src_y, src_w, src_h, dest_x, dest_y,
                      dest_w, dest_h, filter, paint, remove_image_scale);
 }
 
 void Canvas::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) {
   int src_x = 0;
   int src_y = 0;
   int src_w = image_rep.pixel_width();
   int src_h = image_rep.pixel_height();
   // Don't remove image scale here, this function is used to draw the
   // (already scaled) |image_rep| at a 1:1 scale with the canvas.
   bool remove_image_scale = false;
   DrawImageIntHelper(image_rep, src_x, src_y, src_w, src_h, dest_x, dest_y,
                      dest_w, dest_h, filter, paint, remove_image_scale);
 }
 
 void Canvas::DrawImageInPath(const ImageSkia& image,
                              int x,
                              int y,
                              const SkPath& path,
-                             const SkPaint& paint) {
+                             const cc::PaintFlags& paint) {
   const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return;
 
   SkMatrix matrix;
   matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
-  SkPaint p(paint);
-  p.setShader(CreateImageRepShader(image_rep,
-                                   SkShader::kRepeat_TileMode,
-                                   matrix));
+  cc::PaintFlags p(paint);
+  p.setShader(
+      CreateImageRepShader(image_rep, SkShader::kRepeat_TileMode, matrix));
   canvas_->drawPath(path, p);
 }
 
 void Canvas::DrawStringRect(const base::string16& text,
                             const FontList& font_list,
                             SkColor color,
                             const Rect& display_rect) {
   DrawStringRectWithFlags(text, font_list, color, display_rect,
                           DefaultCanvasTextAlignment());
 }
@@ skipping 25 matching lines @@
                           int dest_y,
                           int w,
                           int h) {
   SkRect dest_rect = { SkIntToScalar(dest_x),
                        SkIntToScalar(dest_y),
                        SkIntToScalar(dest_x + w),
                        SkIntToScalar(dest_y + h) };
   if (!IntersectsClipRect(dest_rect))
     return;
 
-  SkPaint paint;
-  if (InitSkPaintForTiling(image, src_x, src_y, tile_scale_x, tile_scale_y,
-                           dest_x, dest_y, &paint))
+  cc::PaintFlags paint;
+  if (InitPaintFlagsForTiling(image, src_x, src_y, tile_scale_x, tile_scale_y,
+                              dest_x, dest_y, &paint))
     canvas_->drawRect(dest_rect, paint);
 }
 
-bool Canvas::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 Canvas::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) {
   const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return false;
 
   SkMatrix shader_scale;
   shader_scale.setScale(SkFloatToScalar(tile_scale_x),
                         SkFloatToScalar(tile_scale_y));
   shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
   shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
 
@@ skipping 15 matching lines @@
 void Canvas::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) {
   DLOG_ASSERT(src_x + src_w < std::numeric_limits<int16_t>::max() &&
               src_y + src_h < std::numeric_limits<int16_t>::max());
   if (src_w <= 0 || src_h <= 0) {
     NOTREACHED() << "Attempting to draw bitmap from an empty rect!";
     return;
   }
 
   SkRect dest_rect = { SkIntToScalar(dest_x),
                        SkIntToScalar(dest_y),
                        SkIntToScalar(dest_x + dest_w),
                        SkIntToScalar(dest_y + dest_h) };
   if (!IntersectsClipRect(dest_rect))
     return;
 
   float user_scale_x = static_cast<float>(dest_w) / src_w;
   float user_scale_y = static_cast<float>(dest_h) / src_h;
 
   // Make a bitmap shader that contains the bitmap we want to draw. This is
   // basically what SkCanvas.drawBitmap does internally, but it gives us
   // more control over quality and will use the mipmap in the source image if
   // it has one, whereas drawBitmap won't.
   SkMatrix shader_scale;
   shader_scale.setScale(SkFloatToScalar(user_scale_x),
                         SkFloatToScalar(user_scale_y));
   shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
   shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
 
-  SkPaint p(paint);
+  cc::PaintFlags p(paint);
   p.setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
   p.setShader(CreateImageRepShaderForScale(
       image_rep, SkShader::kRepeat_TileMode, shader_scale,
       remove_image_scale ? image_rep.scale() : 1.f));
 
   // The rect will be filled by the bitmap.
   canvas_->drawRect(dest_rect, p);
 }
 
 }  // namespace gfx