Rename paint data structures

ui/native_theme/native_theme_base.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_base.h"
 
 #include <limits>
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "third_party/skia/include/core/SkPaint.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/paint_shader.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
@@ skipping 126 matching lines @@
     case kWindowResizeGripper:
       NOTIMPLEMENTED();
       break;
     default:
       NOTREACHED() << "Unknown theme part: " << part;
       break;
   }
   return gfx::Size();
 }
 
-void NativeThemeBase::Paint(SkCanvas* canvas,
+void NativeThemeBase::Paint(cc::PaintCanvas* canvas,
                             Part part,
                             State state,
                             const gfx::Rect& rect,
                             const ExtraParams& extra) const {
   if (rect.IsEmpty())
     return;
 
   canvas->save();
   canvas->clipRect(gfx::RectToSkRect(rect));
 
@@ skipping 81 matching lines @@
 }
 
 NativeThemeBase::NativeThemeBase()
     : scrollbar_width_(kDefaultScrollbarWidth),
       scrollbar_button_length_(kDefaultScrollbarButtonLength) {
 }
 
 NativeThemeBase::~NativeThemeBase() {
 }
 
-void NativeThemeBase::PaintArrowButton(
-    SkCanvas* canvas,
-    const gfx::Rect& rect, Part direction, State state) const {
-  SkPaint paint;
+void NativeThemeBase::PaintArrowButton(cc::PaintCanvas* canvas,
+                                       const gfx::Rect& rect,
+                                       Part direction,
+                                       State state) const {
+  cc::PaintFlags paint;
 
   // Calculate button color.
   SkScalar trackHSV[3];
   SkColorToHSV(track_color_, trackHSV);
   SkColor buttonColor = SaturateAndBrighten(trackHSV, 0, 0.2f);
   SkColor backgroundColor = buttonColor;
   if (state == kPressed) {
     SkScalar buttonHSV[3];
     SkColorToHSV(buttonColor, buttonHSV);
     buttonColor = SaturateAndBrighten(buttonHSV, 0, -0.1f);
@@ skipping 43 matching lines @@
       outline.rLineTo(-2, 2);
       outline.rLineTo(0, rect.height() - 5);
       outline.rLineTo(2, 2);
       outline.rLineTo(rect.width() - 2, 0);
       break;
     default:
       break;
   }
   outline.close();
 
-  paint.setStyle(SkPaint::kFill_Style);
+  paint.setStyle(cc::PaintFlags::kFill_Style);
   paint.setColor(buttonColor);
   canvas->drawPath(outline, paint);
 
   paint.setAntiAlias(true);
-  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setStyle(cc::PaintFlags::kStroke_Style);
   SkScalar thumbHSV[3];
   SkColorToHSV(thumb_inactive_color_, thumbHSV);
   paint.setColor(OutlineColor(trackHSV, thumbHSV));
   canvas->drawPath(outline, paint);
 
   PaintArrow(canvas, rect, direction, GetArrowColor(state));
 }
 
-void NativeThemeBase::PaintArrow(SkCanvas* gc,
+void NativeThemeBase::PaintArrow(cc::PaintCanvas* gc,
                                  const gfx::Rect& rect,
                                  Part direction,
                                  SkColor color) const {
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(color);
 
   SkPath path = PathForArrow(rect, direction);
 
   gc->drawPath(path, paint);
 }
 
 SkPath NativeThemeBase::PathForArrow(const gfx::Rect& rect,
                                      Part direction) const {
   gfx::Rect bounding_rect = BoundingRectForArrow(rect);
@@ skipping 32 matching lines @@
       std::minmax(rect.width(), rect.height());
   const int side_length_inset = 2 * std::ceil(rect_sides.second / 4.f);
   const int side_length =
       std::min(rect_sides.first, rect_sides.second - side_length_inset);
   // When there are an odd number of pixels, put the extra on the top/left.
   return gfx::Rect(rect.x() + (rect.width() - side_length + 1) / 2,
                    rect.y() + (rect.height() - side_length + 1) / 2,
                    side_length, side_length);
 }
 
-void NativeThemeBase::PaintScrollbarTrack(SkCanvas* canvas,
+void NativeThemeBase::PaintScrollbarTrack(
+    cc::PaintCanvas* canvas,
     Part part,
     State state,
     const ScrollbarTrackExtraParams& extra_params,
     const gfx::Rect& rect) const {
-  SkPaint paint;
+  cc::PaintFlags paint;
   SkIRect skrect;
 
   skrect.set(rect.x(), rect.y(), rect.right(), rect.bottom());
   SkScalar track_hsv[3];
   SkColorToHSV(track_color_, track_hsv);
   paint.setColor(SaturateAndBrighten(track_hsv, 0, 0));
   canvas->drawIRect(skrect, paint);
 
   SkScalar thumb_hsv[3];
   SkColorToHSV(thumb_inactive_color_, thumb_hsv);
 
   paint.setColor(OutlineColor(track_hsv, thumb_hsv));
   DrawBox(canvas, rect, paint);
 }
 
-void NativeThemeBase::PaintScrollbarThumb(SkCanvas* canvas,
+void NativeThemeBase::PaintScrollbarThumb(cc::PaintCanvas* canvas,
                                           Part part,
                                           State state,
                                           const gfx::Rect& rect,
                                           ScrollbarOverlayColorTheme) const {
   const bool hovered = state == kHovered;
   const int midx = rect.x() + rect.width() / 2;
   const int midy = rect.y() + rect.height() / 2;
   const bool vertical = part == kScrollbarVerticalThumb;
 
   SkScalar thumb[3];
   SkColorToHSV(hovered ? thumb_active_color_ : thumb_inactive_color_, thumb);
 
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(SaturateAndBrighten(thumb, 0, 0.02f));
 
   SkIRect skrect;
   if (vertical)
     skrect.set(rect.x(), rect.y(), midx + 1, rect.y() + rect.height());
   else
     skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), midy + 1);
 
   canvas->drawIRect(skrect, paint);
 
@@ skipping 46 matching lines @@
                    paint);
       DrawVertLine(canvas,
                    midx + inter_grippy_offset,
                    midy - grippy_half_width,
                    midy + grippy_half_width,
                    paint);
     }
   }
 }
 
-void NativeThemeBase::PaintScrollbarCorner(SkCanvas* canvas,
+void NativeThemeBase::PaintScrollbarCorner(cc::PaintCanvas* canvas,
                                            State state,
-                                           const gfx::Rect& rect) const {
-}
+                                           const gfx::Rect& rect) const {}
 
-void NativeThemeBase::PaintCheckbox(SkCanvas* canvas,
+void NativeThemeBase::PaintCheckbox(cc::PaintCanvas* canvas,
                                     State state,
                                     const gfx::Rect& rect,
                                     const ButtonExtraParams& button) const {
   SkRect skrect = PaintCheckboxRadioCommon(canvas, state, rect,
                                            SkIntToScalar(2));
   if (!skrect.isEmpty()) {
     // Draw the checkmark / dash.
-    SkPaint paint;
+    cc::PaintFlags paint;
     paint.setAntiAlias(true);
-    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStyle(cc::PaintFlags::kStroke_Style);
     if (state == kDisabled)
       paint.setColor(kCheckboxStrokeDisabledColor);
     else
       paint.setColor(kCheckboxStrokeColor);
     if (button.indeterminate) {
       SkPath dash;
       dash.moveTo(skrect.x() + skrect.width() * 0.16,
                   (skrect.y() + skrect.bottom()) / 2);
       dash.rLineTo(skrect.width() * 0.68, 0);
       paint.setStrokeWidth(SkFloatToScalar(skrect.height() * 0.2));
       canvas->drawPath(dash, paint);
     } else if (button.checked) {
       SkPath check;
       check.moveTo(skrect.x() + skrect.width() * 0.2,
                    skrect.y() + skrect.height() * 0.5);
       check.rLineTo(skrect.width() * 0.2, skrect.height() * 0.2);
       paint.setStrokeWidth(SkFloatToScalar(skrect.height() * 0.23));
       check.lineTo(skrect.right() - skrect.width() * 0.2,
                    skrect.y() + skrect.height() * 0.2);
       canvas->drawPath(check, paint);
     }
   }
 }
 
 // Draws the common elements of checkboxes and radio buttons.
 // Returns the rectangle within which any additional decorations should be
 // drawn, or empty if none.
 SkRect NativeThemeBase::PaintCheckboxRadioCommon(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const SkScalar borderRadius) const {
-
   SkRect skrect = gfx::RectToSkRect(rect);
 
   // Use the largest square that fits inside the provided rectangle.
   // No other browser seems to support non-square widget, so accidentally
   // having non-square sizes is common (eg. amazon and webkit dev tools).
   if (skrect.width() != skrect.height()) {
     SkScalar size = SkMinScalar(skrect.width(), skrect.height());
     skrect.inset((skrect.width() - size) / 2, (skrect.height() - size) / 2);
   }
 
   // If the rectangle is too small then paint only a rectangle.  We don't want
   // to have to worry about '- 1' and '+ 1' calculations below having overflow
   // or underflow.
   if (skrect.width() <= 2) {
-    SkPaint paint;
+    cc::PaintFlags paint;
     paint.setColor(kCheckboxTinyColor);
-    paint.setStyle(SkPaint::kFill_Style);
+    paint.setStyle(cc::PaintFlags::kFill_Style);
     canvas->drawRect(skrect, paint);
     // Too small to draw anything more.
     return SkRect::MakeEmpty();
   }
 
   // Make room for padding/drop shadow.
   AdjustCheckboxRadioRectForPadding(&skrect);
 
   // Draw the drop shadow below the widget.
   if (state != kPressed) {
-    SkPaint paint;
+    cc::PaintFlags paint;
     paint.setAntiAlias(true);
     SkRect shadowRect = skrect;
     shadowRect.offset(0, 1);
     if (state == kDisabled)
      paint.setColor(kCheckboxShadowDisabledColor);
     else if (state == kHovered)
       paint.setColor(kCheckboxShadowHoveredColor);
     else
       paint.setColor(kCheckboxShadowColor);
-    paint.setStyle(SkPaint::kFill_Style);
+    paint.setStyle(cc::PaintFlags::kFill_Style);
     canvas->drawRoundRect(shadowRect, borderRadius, borderRadius, paint);
   }
 
   // Draw the gradient-filled rectangle
   SkPoint gradient_bounds[3];
   gradient_bounds[0].set(skrect.x(), skrect.y());
   gradient_bounds[1].set(skrect.x(), skrect.y() + skrect.height() * 0.38);
   gradient_bounds[2].set(skrect.x(), skrect.bottom());
   const SkColor* startEndColors;
   if (state == kPressed)
     startEndColors = kCheckboxGradientPressedColors;
   else if (state == kHovered)
     startEndColors = kCheckboxGradientHoveredColors;
   else if (state == kDisabled)
     startEndColors = kCheckboxGradientDisabledColors;
   else /* kNormal */
     startEndColors = kCheckboxGradientColors;
   SkColor colors[3] = {startEndColors[0], startEndColors[0], startEndColors[1]};
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setAntiAlias(true);
-  paint.setShader(SkGradientShader::MakeLinear(gradient_bounds, colors, NULL, 3,
-                                               SkShader::kClamp_TileMode));
-  paint.setStyle(SkPaint::kFill_Style);
+  paint.setShader(cc::WrapSkShader(SkGradientShader::MakeLinear(
+      gradient_bounds, colors, NULL, 3, SkShader::kClamp_TileMode)));
+  paint.setStyle(cc::PaintFlags::kFill_Style);
   canvas->drawRoundRect(skrect, borderRadius, borderRadius, paint);
   paint.setShader(NULL);
 
   // Draw the border.
   if (state == kHovered)
     paint.setColor(kCheckboxBorderHoveredColor);
   else if (state == kDisabled)
     paint.setColor(kCheckboxBorderDisabledColor);
   else
     paint.setColor(kCheckboxBorderColor);
-  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setStyle(cc::PaintFlags::kStroke_Style);
   paint.setStrokeWidth(SkIntToScalar(1));
   skrect.inset(SkFloatToScalar(.5f), SkFloatToScalar(.5f));
   canvas->drawRoundRect(skrect, borderRadius, borderRadius, paint);
 
   // Return the rectangle excluding the drop shadow for drawing any additional
   // decorations.
   return skrect;
 }
 
-void NativeThemeBase::PaintRadio(SkCanvas* canvas,
-                                  State state,
-                                  const gfx::Rect& rect,
-                                  const ButtonExtraParams& button) const {
-
+void NativeThemeBase::PaintRadio(cc::PaintCanvas* canvas,
+                                 State state,
+                                 const gfx::Rect& rect,
+                                 const ButtonExtraParams& button) const {
   // Most of a radio button is the same as a checkbox, except the the rounded
   // square is a circle (i.e. border radius >= 100%).
   const SkScalar radius = SkFloatToScalar(
       static_cast<float>(std::max(rect.width(), rect.height())) / 2);
   SkRect skrect = PaintCheckboxRadioCommon(canvas, state, rect, radius);
   if (!skrect.isEmpty() && button.checked) {
     // Draw the dot.
-    SkPaint paint;
+    cc::PaintFlags paint;
     paint.setAntiAlias(true);
-    paint.setStyle(SkPaint::kFill_Style);
+    paint.setStyle(cc::PaintFlags::kFill_Style);
     if (state == kDisabled)
       paint.setColor(kRadioDotDisabledColor);
     else
       paint.setColor(kRadioDotColor);
     skrect.inset(skrect.width() * 0.25, skrect.height() * 0.25);
     // Use drawRoundedRect instead of drawOval to be completely consistent
     // with the border in PaintCheckboxRadioNewCommon.
     canvas->drawRoundRect(skrect, radius, radius, paint);
   }
 }
 
-void NativeThemeBase::PaintButton(SkCanvas* canvas,
+void NativeThemeBase::PaintButton(cc::PaintCanvas* canvas,
                                   State state,
                                   const gfx::Rect& rect,
                                   const ButtonExtraParams& button) const {
-  SkPaint paint;
+  cc::PaintFlags paint;
   SkRect skrect = gfx::RectToSkRect(rect);
   SkColor base_color = button.background_color;
 
   color_utils::HSL base_hsl;
   color_utils::SkColorToHSL(base_color, &base_hsl);
 
   // Our standard gradient is from 0xdd to 0xf8. This is the amount of
   // increased luminance between those values.
   SkColor light_color(BrightenColor(base_hsl, SkColorGetA(base_color), 0.105));
 
   // If the button is too small, fallback to drawing a single, solid color
   if (rect.width() < 5 || rect.height() < 5) {
     paint.setColor(base_color);
     canvas->drawRect(skrect, paint);
     return;
   }
 
   paint.setColor(SK_ColorBLACK);
   SkPoint gradient_bounds[2] = {
     gfx::PointToSkPoint(rect.origin()),
     gfx::PointToSkPoint(rect.bottom_left() - gfx::Vector2d(0, 1))
   };
   if (state == kPressed)
     std::swap(gradient_bounds[0], gradient_bounds[1]);
   SkColor colors[2] = { light_color, base_color };
 
-  paint.setStyle(SkPaint::kFill_Style);
+  paint.setStyle(cc::PaintFlags::kFill_Style);
   paint.setAntiAlias(true);
-  paint.setShader(
-      SkGradientShader::MakeLinear(
-          gradient_bounds, colors, NULL, 2, SkShader::kClamp_TileMode));
+  paint.setShader(cc::WrapSkShader(SkGradientShader::MakeLinear(
+      gradient_bounds, colors, NULL, 2, SkShader::kClamp_TileMode)));
 
   canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), paint);
   paint.setShader(NULL);
 
   if (button.has_border) {
     int border_alpha = state == kHovered ? 0x80 : 0x55;
     if (button.is_focused) {
       border_alpha = 0xff;
       paint.setColor(GetSystemColor(kColorId_FocusedBorderColor));
     }
-    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStyle(cc::PaintFlags::kStroke_Style);
     paint.setStrokeWidth(SkIntToScalar(1));
     paint.setAlpha(border_alpha);
     skrect.inset(SkFloatToScalar(.5f), SkFloatToScalar(.5f));
     canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), paint);
   }
 }
 
-void NativeThemeBase::PaintTextField(SkCanvas* canvas,
+void NativeThemeBase::PaintTextField(cc::PaintCanvas* canvas,
                                      State state,
                                      const gfx::Rect& rect,
                                      const TextFieldExtraParams& text) const {
   SkRect bounds;
   bounds.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
 
-  SkPaint fill_paint;
-  fill_paint.setStyle(SkPaint::kFill_Style);
+  cc::PaintFlags fill_paint;
+  fill_paint.setStyle(cc::PaintFlags::kFill_Style);
   fill_paint.setColor(text.background_color);
   canvas->drawRect(bounds, fill_paint);
 
   // Text INPUT, listbox SELECT, and TEXTAREA have consistent borders.
   // border: 1px solid #a9a9a9
-  SkPaint stroke_paint;
-  stroke_paint.setStyle(SkPaint::kStroke_Style);
+  cc::PaintFlags stroke_paint;
+  stroke_paint.setStyle(cc::PaintFlags::kStroke_Style);
   stroke_paint.setColor(kTextBorderColor);
   canvas->drawRect(bounds, stroke_paint);
 }
 
 void NativeThemeBase::PaintMenuList(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const MenuListExtraParams& menu_list) const {
   // If a border radius is specified, we let the WebCore paint the background
   // and the border of the control.
   if (!menu_list.has_border_radius) {
     ButtonExtraParams button = { 0 };
     button.background_color = menu_list.background_color;
     button.has_border = menu_list.has_border;
     PaintButton(canvas, state, rect, button);
   }
 
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(menu_list.arrow_color);
   paint.setAntiAlias(true);
-  paint.setStyle(SkPaint::kFill_Style);
+  paint.setStyle(cc::PaintFlags::kFill_Style);
 
   int arrow_size = menu_list.arrow_size;
   gfx::Rect arrow(
     menu_list.arrow_x,
     menu_list.arrow_y - (arrow_size / 2),
     arrow_size,
     arrow_size);
 
   // Constrain to the paint rect.
   arrow.Intersect(rect);
 
   SkPath path;
   path.moveTo(arrow.x(), arrow.y());
   path.lineTo(arrow.right(), arrow.y());
   path.lineTo(arrow.x() + arrow.width() / 2, arrow.bottom());
   path.close();
   canvas->drawPath(path, paint);
 }
 
 void NativeThemeBase::PaintMenuPopupBackground(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     const gfx::Size& size,
     const MenuBackgroundExtraParams& menu_background) const {
   canvas->drawColor(kMenuPopupBackgroundColor, SkBlendMode::kSrc);
 }
 
 void NativeThemeBase::PaintMenuItemBackground(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const MenuItemExtraParams& menu_item) const {
   // By default don't draw anything over the normal background.
 }
 
 void NativeThemeBase::PaintMenuSeparator(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const MenuSeparatorExtraParams& menu_separator) const {
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(GetSystemColor(ui::NativeTheme::kColorId_MenuSeparatorColor));
   canvas->drawRect(gfx::RectToSkRect(*menu_separator.paint_rect), paint);
 }
 
-void NativeThemeBase::PaintSliderTrack(SkCanvas* canvas,
+void NativeThemeBase::PaintSliderTrack(cc::PaintCanvas* canvas,
                                        State state,
                                        const gfx::Rect& rect,
                                        const SliderExtraParams& slider) const {
   const int kMidX = rect.x() + rect.width() / 2;
   const int kMidY = rect.y() + rect.height() / 2;
 
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(kSliderTrackBackgroundColor);
 
   SkRect skrect;
   if (slider.vertical) {
     skrect.set(std::max(rect.x(), kMidX - 2),
                rect.y(),
                std::min(rect.right(), kMidX + 2),
                rect.bottom());
   } else {
     skrect.set(rect.x(),
                std::max(rect.y(), kMidY - 2),
                rect.right(),
                std::min(rect.bottom(), kMidY + 2));
   }
   canvas->drawRect(skrect, paint);
 }
 
-void NativeThemeBase::PaintSliderThumb(SkCanvas* canvas,
+void NativeThemeBase::PaintSliderThumb(cc::PaintCanvas* canvas,
                                        State state,
                                        const gfx::Rect& rect,
                                        const SliderExtraParams& slider) const {
   const bool hovered = (state == kHovered) || slider.in_drag;
   const int kMidX = rect.x() + rect.width() / 2;
   const int kMidY = rect.y() + rect.height() / 2;
 
-  SkPaint paint;
+  cc::PaintFlags paint;
   paint.setColor(hovered ? SK_ColorWHITE : kSliderThumbLightGrey);
 
   SkIRect skrect;
   if (slider.vertical)
     skrect.set(rect.x(), rect.y(), kMidX + 1, rect.bottom());
   else
     skrect.set(rect.x(), rect.y(), rect.right(), kMidY + 1);
 
   canvas->drawIRect(skrect, paint);
 
   paint.setColor(hovered ? kSliderThumbLightGrey : kSliderThumbDarkGrey);
 
   if (slider.vertical)
     skrect.set(kMidX + 1, rect.y(), rect.right(), rect.bottom());
   else
     skrect.set(rect.x(), kMidY + 1, rect.right(), rect.bottom());
 
   canvas->drawIRect(skrect, paint);
 
   paint.setColor(kSliderThumbBorderDarkGrey);
   DrawBox(canvas, rect, paint);
 
   if (rect.height() > 10 && rect.width() > 10) {
     DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY, paint);
     DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY - 3, paint);
     DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY + 3, paint);
   }
 }
 
-void NativeThemeBase::PaintInnerSpinButton(SkCanvas* canvas,
+void NativeThemeBase::PaintInnerSpinButton(
+    cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const InnerSpinButtonExtraParams& spin_button) const {
   if (spin_button.read_only)
     state = kDisabled;
 
   State north_state = state;
   State south_state = state;
   if (spin_button.spin_up)
     south_state = south_state != kDisabled ? kNormal : kDisabled;
   else
     north_state = north_state != kDisabled ? kNormal : kDisabled;
 
   gfx::Rect half = rect;
   half.set_height(rect.height() / 2);
   PaintArrowButton(canvas, half, kScrollbarUpArrow, north_state);
 
   half.set_y(rect.y() + rect.height() / 2);
   PaintArrowButton(canvas, half, kScrollbarDownArrow, south_state);
 }
 
 void NativeThemeBase::PaintProgressBar(
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const ProgressBarExtraParams& progress_bar) const {
   DCHECK(!rect.IsEmpty());
 
   canvas->drawColor(SK_ColorWHITE);
 
   // Draw the tick marks. The spacing between the tick marks is adjusted to
   // evenly divide into the width.
   SkPath path;
   int stroke_width = std::max(1, rect.height() / 18);
   int tick_width = 16 * stroke_width;
   int ticks = rect.width() / tick_width + (rect.width() % tick_width ? 1 : 0);
   SkScalar tick_spacing = SkIntToScalar(rect.width()) / ticks;
   for (int i = 1; i < ticks; ++i) {
     path.moveTo(rect.x() + i * tick_spacing, rect.y());
     path.rLineTo(0, rect.height());
   }
-  SkPaint stroke_paint;
+  cc::PaintFlags stroke_paint;
   stroke_paint.setColor(kProgressTickColor);
-  stroke_paint.setStyle(SkPaint::kStroke_Style);
+  stroke_paint.setStyle(cc::PaintFlags::kStroke_Style);
   stroke_paint.setStrokeWidth(stroke_width);
   canvas->drawPath(path, stroke_paint);
 
   // Draw progress.
   gfx::Rect progress_rect(progress_bar.value_rect_x, progress_bar.value_rect_y,
                           progress_bar.value_rect_width,
                           progress_bar.value_rect_height);
-  SkPaint progress_paint;
+  cc::PaintFlags progress_paint;
   progress_paint.setColor(kProgressValueColor);
-  progress_paint.setStyle(SkPaint::kFill_Style);
+  progress_paint.setStyle(cc::PaintFlags::kFill_Style);
   canvas->drawRect(gfx::RectToSkRect(progress_rect), progress_paint);
 
   // Draw the border.
   gfx::RectF border_rect(rect);
   border_rect.Inset(stroke_width / 2.0f, stroke_width / 2.0f);
   stroke_paint.setColor(kProgressBorderColor);
   canvas->drawRect(gfx::RectFToSkRect(border_rect), stroke_paint);
 }
 
 void NativeThemeBase::PaintFrameTopArea(
@@ skipping 25 matching lines @@
   if (state != kDisabled)
     return SK_ColorBLACK;
 
   SkScalar track_hsv[3];
   SkColorToHSV(track_color_, track_hsv);
   SkScalar thumb_hsv[3];
   SkColorToHSV(thumb_inactive_color_, thumb_hsv);
   return OutlineColor(track_hsv, thumb_hsv);
 }
 
-void NativeThemeBase::DrawVertLine(SkCanvas* canvas,
+void NativeThemeBase::DrawVertLine(cc::PaintCanvas* canvas,
                                    int x,
                                    int y1,
                                    int y2,
-                                   const SkPaint& paint) const {
+                                   const cc::PaintFlags& paint) const {
   SkIRect skrect;
   skrect.set(x, y1, x + 1, y2 + 1);
   canvas->drawIRect(skrect, paint);
 }
 
-void NativeThemeBase::DrawHorizLine(SkCanvas* canvas,
+void NativeThemeBase::DrawHorizLine(cc::PaintCanvas* canvas,
                                     int x1,
                                     int x2,
                                     int y,
-                                    const SkPaint& paint) const {
+                                    const cc::PaintFlags& paint) const {
   SkIRect skrect;
   skrect.set(x1, y, x2 + 1, y + 1);
   canvas->drawIRect(skrect, paint);
 }
 
-void NativeThemeBase::DrawBox(SkCanvas* canvas,
+void NativeThemeBase::DrawBox(cc::PaintCanvas* canvas,
                               const gfx::Rect& rect,
-                              const SkPaint& paint) const {
+                              const cc::PaintFlags& paint) const {
   const int right = rect.x() + rect.width() - 1;
   const int bottom = rect.y() + rect.height() - 1;
   DrawHorizLine(canvas, rect.x(), right, rect.y(), paint);
   DrawVertLine(canvas, right, rect.y(), bottom, paint);
   DrawHorizLine(canvas, rect.x(), right, bottom, paint);
   DrawVertLine(canvas, rect.x(), rect.y(), bottom, paint);
 }
 
 SkScalar NativeThemeBase::Clamp(SkScalar value,
                                 SkScalar min,
@@ skipping 32 matching lines @@
   SkScalar min_diff = Clamp((hsv1[1] + hsv2[1]) * 1.2f, 0.28f, 0.5f);
   SkScalar diff = Clamp(fabs(hsv1[2] - hsv2[2]) / 2, min_diff, 0.5f);
 
   if (hsv1[2] + hsv2[2] > 1.0)
     diff = -diff;
 
   return SaturateAndBrighten(hsv2, -0.2f, diff);
 }
 
 }  // namespace ui