Rename paint data structures

ui/native_theme/native_theme_aura.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/native_theme/native_theme_aura.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_flags.h"
 #include "ui/base/layout.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
@@ skipping 65 matching lines @@
                          (IsOverlayScrollbarEnabled()));
   return &s_native_theme_for_web;
 }
 
 // This implementation returns hardcoded colors.
 SkColor NativeThemeAura::GetSystemColor(ColorId color_id) const {
   return GetAuraColor(color_id, this);
 }
 
 void NativeThemeAura::PaintMenuPopupBackground(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     const gfx::Size& size,
     const MenuBackgroundExtraParams& menu_background) const {
   SkColor color = GetSystemColor(NativeTheme::kColorId_MenuBackgroundColor);
   if (menu_background.corner_radius > 0) {
-    SkPaint paint;
-    paint.setStyle(SkPaint::kFill_Style);
-    paint.setFlags(SkPaint::kAntiAlias_Flag);
+    cc::PaintFlags paint;
+    paint.setStyle(cc::PaintFlags::kFill_Style);
+    paint.setAntiAlias(true);
     paint.setColor(color);
 
     gfx::Path path;
     SkRect rect = SkRect::MakeWH(SkIntToScalar(size.width()),
                                  SkIntToScalar(size.height()));
     SkScalar radius = SkIntToScalar(menu_background.corner_radius);
     SkScalar radii[8] = {radius, radius, radius, radius,
                          radius, radius, radius, radius};
     path.addRoundRect(rect, radii);
 
     canvas->drawPath(path, paint);
   } else {
     canvas->drawColor(color, SkBlendMode::kSrc);
   }
 }
 
 void NativeThemeAura::PaintMenuItemBackground(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const MenuItemExtraParams& menu_item) const {
   CommonThemePaintMenuItemBackground(this, canvas, state, rect, menu_item);
 }
 
-void NativeThemeAura::PaintArrowButton(SkCanvas* canvas,
+void NativeThemeAura::PaintArrowButton(cc::PaintCanvas* canvas,
                                        const gfx::Rect& rect,
                                        Part direction,
                                        State state) const {
   SkColor bg_color = kTrackColor;
   // Aura-win uses slightly different arrow colors.
   SkColor arrow_color = gfx::kPlaceholderColor;
   switch (state) {
     case kDisabled:
       arrow_color = GetArrowColor(state);
       break;
     case kHovered:
       bg_color = SkColorSetRGB(0xD2, 0xD2, 0xD2);
     // Fall through.
     case kNormal:
       arrow_color = SkColorSetRGB(0x50, 0x50, 0x50);
       break;
     case kPressed:
       bg_color = SkColorSetRGB(0x78, 0x78, 0x78);
       arrow_color = SK_ColorWHITE;
       break;
     case kNumStates:
       break;
   }
   DCHECK_NE(arrow_color, gfx::kPlaceholderColor);
 
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(bg_color);
   canvas->drawIRect(gfx::RectToSkIRect(rect), paint);
 
   PaintArrow(canvas, rect, direction, arrow_color);
 }
 
 void NativeThemeAura::PaintScrollbarTrack(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     Part part,
     State state,
     const ScrollbarTrackExtraParams& extra_params,
     const gfx::Rect& rect) const {
   // Overlay Scrollbar should never paint a scrollbar track.
   DCHECK(!use_overlay_scrollbars_);
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(kTrackColor);
   canvas->drawIRect(gfx::RectToSkIRect(rect), paint);
 }
 
 void NativeThemeAura::PaintScrollbarThumb(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     Part part,
     State state,
     const gfx::Rect& rect,
     ScrollbarOverlayColorTheme theme) const {
   // Do not paint if state is disabled.
   if (state == kDisabled)
     return;
 
   TRACE_EVENT0("blink", "NativeThemeAura::PaintScrollbarThumb");
 
@@ skipping 36 matching lines @@
         thumb_alpha = kOverlayScrollbarFillAlphaPressed;
         stroke_alpha = kOverlayScrollbarStrokeAlphaPressed;
         break;
       case NativeTheme::kNumStates:
         NOTREACHED();
         break;
     }
 
     // In overlay mode, draw a stroke (border).
     constexpr int kStrokeWidth = kOverlayScrollbarStrokeWidth;
-    SkPaint paint;
+    cc::PaintFlags paint;
     paint.setColor(
         SkColorSetA(kOverlayScrollbarStrokeColor[theme], stroke_alpha));
-    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStyle(cc::PaintFlags::kStroke_Style);
     paint.setStrokeWidth(kStrokeWidth);
 
     gfx::RectF stroke_rect(thumb_rect);
     constexpr float kHalfStrokeWidth = kStrokeWidth / 2.f;
     stroke_rect.Inset(kHalfStrokeWidth, kHalfStrokeWidth);
     canvas->drawRect(gfx::RectFToSkRect(stroke_rect), paint);
 
     // Inset the all the edges edges so we fill-in the stroke below.
     thumb_rect.Inset(kStrokeWidth, kStrokeWidth);
   } else {
@@ skipping 20 matching lines @@
     const int extra_padding =
         (scrollbar_button_length() == 0) ? kThumbPadding : 0;
     if (part == NativeTheme::kScrollbarVerticalThumb)
       thumb_rect.Inset(kThumbPadding, extra_padding);
     else
       thumb_rect.Inset(extra_padding, kThumbPadding);
 
     thumb_color = SK_ColorBLACK;
   }
 
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(SkColorSetA(thumb_color, thumb_alpha));
   canvas->drawIRect(gfx::RectToSkIRect(thumb_rect), paint);
 }
 
-void NativeThemeAura::PaintScrollbarCorner(SkCanvas* canvas,
+void NativeThemeAura::PaintScrollbarCorner(cc::PaintCanvas* canvas,
                                            State state,
                                            const gfx::Rect& rect) const {
   // Overlay Scrollbar should never paint a scrollbar corner.
   DCHECK(!use_overlay_scrollbars_);
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(SkColorSetRGB(0xDC, 0xDC, 0xDC));
   canvas->drawIRect(RectToSkIRect(rect), paint);
 }
 
 gfx::Size NativeThemeAura::GetPartSize(Part part,
                                        State state,
                                        const ExtraParams& extra) const {
   if (use_overlay_scrollbars_) {
     constexpr int minimum_length =
         kOverlayScrollbarMinimumLength + 2 * kOverlayScrollbarStrokeWidth;
@@ skipping 10 matching lines @@
         // scrollbars isn't asking for part sizes that don't exist.
         // crbug.com/657159.
         break;
     }
   }
 
   return NativeThemeBase::GetPartSize(part, state, extra);
 }
 
 }  // namespace ui