ui: Clean up naming of paint-related identifiers

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"
@@ skipping 245 matching lines @@
       scrollbar_button_length_(kDefaultScrollbarButtonLength) {
 }
 
 NativeThemeBase::~NativeThemeBase() {
 }
 
 void NativeThemeBase::PaintArrowButton(cc::PaintCanvas* canvas,
                                        const gfx::Rect& rect,
                                        Part direction,
                                        State state) const {
-  cc::PaintFlags paint;
+  cc::PaintFlags flags;
 
   // 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);
   } else if (state == kHovered) {
     SkScalar buttonHSV[3];
     SkColorToHSV(buttonColor, buttonHSV);
     buttonColor = SaturateAndBrighten(buttonHSV, 0, 0.05f);
   }
 
   SkIRect skrect;
   skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y()
       + rect.height());
   // Paint the background (the area visible behind the rounded corners).
-  paint.setColor(backgroundColor);
-  canvas->drawIRect(skrect, paint);
+  flags.setColor(backgroundColor);
+  canvas->drawIRect(skrect, flags);
 
   // Paint the button's outline and fill the middle
   SkPath outline;
   switch (direction) {
     case kScrollbarUpArrow:
       outline.moveTo(rect.x() + 0.5, rect.y() + rect.height() + 0.5);
       outline.rLineTo(0, -(rect.height() - 2));
       outline.rLineTo(2, -2);
       outline.rLineTo(rect.width() - 5, 0);
       outline.rLineTo(2, 2);
@@ skipping 21 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(cc::PaintFlags::kFill_Style);
-  paint.setColor(buttonColor);
-  canvas->drawPath(outline, paint);
+  flags.setStyle(cc::PaintFlags::kFill_Style);
+  flags.setColor(buttonColor);
+  canvas->drawPath(outline, flags);
 
-  paint.setAntiAlias(true);
-  paint.setStyle(cc::PaintFlags::kStroke_Style);
+  flags.setAntiAlias(true);
+  flags.setStyle(cc::PaintFlags::kStroke_Style);
   SkScalar thumbHSV[3];
   SkColorToHSV(thumb_inactive_color_, thumbHSV);
-  paint.setColor(OutlineColor(trackHSV, thumbHSV));
-  canvas->drawPath(outline, paint);
+  flags.setColor(OutlineColor(trackHSV, thumbHSV));
+  canvas->drawPath(outline, flags);
 
   PaintArrow(canvas, rect, direction, GetArrowColor(state));
 }
 
 void NativeThemeBase::PaintArrow(cc::PaintCanvas* gc,
                                  const gfx::Rect& rect,
                                  Part direction,
                                  SkColor color) const {
-  cc::PaintFlags paint;
-  paint.setColor(color);
+  cc::PaintFlags flags;
+  flags.setColor(color);
 
   SkPath path = PathForArrow(rect, direction);
 
-  gc->drawPath(path, paint);
+  gc->drawPath(path, flags);
 }
 
 SkPath NativeThemeBase::PathForArrow(const gfx::Rect& rect,
                                      Part direction) const {
   gfx::Rect bounding_rect = BoundingRectForArrow(rect);
   const gfx::PointF center = gfx::RectF(bounding_rect).CenterPoint();
   SkPath path;
   SkMatrix transform;
   transform.setIdentity();
   if (direction == kScrollbarUpArrow || direction == kScrollbarDownArrow) {
@@ skipping 33 matching lines @@
                    rect.y() + (rect.height() - side_length + 1) / 2,
                    side_length, side_length);
 }
 
 void NativeThemeBase::PaintScrollbarTrack(
     cc::PaintCanvas* canvas,
     Part part,
     State state,
     const ScrollbarTrackExtraParams& extra_params,
     const gfx::Rect& rect) const {
-  cc::PaintFlags paint;
+  cc::PaintFlags flags;
   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);
+  flags.setColor(SaturateAndBrighten(track_hsv, 0, 0));
+  canvas->drawIRect(skrect, flags);
 
   SkScalar thumb_hsv[3];
   SkColorToHSV(thumb_inactive_color_, thumb_hsv);
 
-  paint.setColor(OutlineColor(track_hsv, thumb_hsv));
-  DrawBox(canvas, rect, paint);
+  flags.setColor(OutlineColor(track_hsv, thumb_hsv));
+  DrawBox(canvas, rect, flags);
 }
 
 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);
 
-  cc::PaintFlags paint;
-  paint.setColor(SaturateAndBrighten(thumb, 0, 0.02f));
+  cc::PaintFlags flags;
+  flags.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);
+  canvas->drawIRect(skrect, flags);
 
-  paint.setColor(SaturateAndBrighten(thumb, 0, -0.02f));
+  flags.setColor(SaturateAndBrighten(thumb, 0, -0.02f));
 
   if (vertical) {
     skrect.set(
         midx + 1, rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
   } else {
     skrect.set(
         rect.x(), midy + 1, rect.x() + rect.width(), rect.y() + rect.height());
   }
 
-  canvas->drawIRect(skrect, paint);
+  canvas->drawIRect(skrect, flags);
 
   SkScalar track[3];
   SkColorToHSV(track_color_, track);
-  paint.setColor(OutlineColor(track, thumb));
-  DrawBox(canvas, rect, paint);
+  flags.setColor(OutlineColor(track, thumb));
+  DrawBox(canvas, rect, flags);
 
   if (rect.height() > 10 && rect.width() > 10) {
     const int grippy_half_width = 2;
     const int inter_grippy_offset = 3;
     if (vertical) {
-      DrawHorizLine(canvas,
-                    midx - grippy_half_width,
-                    midx + grippy_half_width,
-                    midy - inter_grippy_offset,
-                    paint);
-      DrawHorizLine(canvas,
-                    midx - grippy_half_width,
-                    midx + grippy_half_width,
-                    midy,
-                    paint);
-      DrawHorizLine(canvas,
-                    midx - grippy_half_width,
-                    midx + grippy_half_width,
-                    midy + inter_grippy_offset,
-                    paint);
+      DrawHorizLine(canvas, midx - grippy_half_width, midx + grippy_half_width,
+                    midy - inter_grippy_offset, flags);
+      DrawHorizLine(canvas, midx - grippy_half_width, midx + grippy_half_width,
+                    midy, flags);
+      DrawHorizLine(canvas, midx - grippy_half_width, midx + grippy_half_width,
+                    midy + inter_grippy_offset, flags);
     } else {
-      DrawVertLine(canvas,
-                   midx - inter_grippy_offset,
-                   midy - grippy_half_width,
-                   midy + grippy_half_width,
-                   paint);
-      DrawVertLine(canvas,
-                   midx,
-                   midy - grippy_half_width,
-                   midy + grippy_half_width,
-                   paint);
-      DrawVertLine(canvas,
-                   midx + inter_grippy_offset,
-                   midy - grippy_half_width,
-                   midy + grippy_half_width,
-                   paint);
+      DrawVertLine(canvas, midx - inter_grippy_offset, midy - grippy_half_width,
+                   midy + grippy_half_width, flags);
+      DrawVertLine(canvas, midx, midy - grippy_half_width,
+                   midy + grippy_half_width, flags);
+      DrawVertLine(canvas, midx + inter_grippy_offset, midy - grippy_half_width,
+                   midy + grippy_half_width, flags);
     }
   }
 }
 
 void NativeThemeBase::PaintScrollbarCorner(cc::PaintCanvas* canvas,
                                            State state,
                                            const gfx::Rect& rect) const {}
 
 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.
-    cc::PaintFlags paint;
-    paint.setAntiAlias(true);
-    paint.setStyle(cc::PaintFlags::kStroke_Style);
+    cc::PaintFlags flags;
+    flags.setAntiAlias(true);
+    flags.setStyle(cc::PaintFlags::kStroke_Style);
     if (state == kDisabled)
-      paint.setColor(kCheckboxStrokeDisabledColor);
+      flags.setColor(kCheckboxStrokeDisabledColor);
     else
-      paint.setColor(kCheckboxStrokeColor);
+      flags.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);
+      flags.setStrokeWidth(SkFloatToScalar(skrect.height() * 0.2));
+      canvas->drawPath(dash, flags);
     } 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));
+      flags.setStrokeWidth(SkFloatToScalar(skrect.height() * 0.23));
       check.lineTo(skrect.right() - skrect.width() * 0.2,
                    skrect.y() + skrect.height() * 0.2);
-      canvas->drawPath(check, paint);
+      canvas->drawPath(check, flags);
     }
   }
 }
 
 // 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(
     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) {
-    cc::PaintFlags paint;
-    paint.setColor(kCheckboxTinyColor);
-    paint.setStyle(cc::PaintFlags::kFill_Style);
-    canvas->drawRect(skrect, paint);
+    cc::PaintFlags flags;
+    flags.setColor(kCheckboxTinyColor);
+    flags.setStyle(cc::PaintFlags::kFill_Style);
+    canvas->drawRect(skrect, flags);
     // 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) {
-    cc::PaintFlags paint;
-    paint.setAntiAlias(true);
+    cc::PaintFlags flags;
+    flags.setAntiAlias(true);
     SkRect shadowRect = skrect;
     shadowRect.offset(0, 1);
     if (state == kDisabled)
-     paint.setColor(kCheckboxShadowDisabledColor);
+      flags.setColor(kCheckboxShadowDisabledColor);
     else if (state == kHovered)
-      paint.setColor(kCheckboxShadowHoveredColor);
+      flags.setColor(kCheckboxShadowHoveredColor);
     else
-      paint.setColor(kCheckboxShadowColor);
-    paint.setStyle(cc::PaintFlags::kFill_Style);
-    canvas->drawRoundRect(shadowRect, borderRadius, borderRadius, paint);
+      flags.setColor(kCheckboxShadowColor);
+    flags.setStyle(cc::PaintFlags::kFill_Style);
+    canvas->drawRoundRect(shadowRect, borderRadius, borderRadius, flags);
   }
 
   // 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]};
-  cc::PaintFlags paint;
-  paint.setAntiAlias(true);
-  paint.setShader(cc::WrapSkShader(SkGradientShader::MakeLinear(
+  cc::PaintFlags flags;
+  flags.setAntiAlias(true);
+  flags.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);
+  flags.setStyle(cc::PaintFlags::kFill_Style);
+  canvas->drawRoundRect(skrect, borderRadius, borderRadius, flags);
+  flags.setShader(NULL);
 
   // Draw the border.
   if (state == kHovered)
-    paint.setColor(kCheckboxBorderHoveredColor);
+    flags.setColor(kCheckboxBorderHoveredColor);
   else if (state == kDisabled)
-    paint.setColor(kCheckboxBorderDisabledColor);
+    flags.setColor(kCheckboxBorderDisabledColor);
   else
-    paint.setColor(kCheckboxBorderColor);
-  paint.setStyle(cc::PaintFlags::kStroke_Style);
-  paint.setStrokeWidth(SkIntToScalar(1));
+    flags.setColor(kCheckboxBorderColor);
+  flags.setStyle(cc::PaintFlags::kStroke_Style);
+  flags.setStrokeWidth(SkIntToScalar(1));
   skrect.inset(SkFloatToScalar(.5f), SkFloatToScalar(.5f));
-  canvas->drawRoundRect(skrect, borderRadius, borderRadius, paint);
+  canvas->drawRoundRect(skrect, borderRadius, borderRadius, flags);
 
   // Return the rectangle excluding the drop shadow for drawing any additional
   // decorations.
   return skrect;
 }
 
 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.
-    cc::PaintFlags paint;
-    paint.setAntiAlias(true);
-    paint.setStyle(cc::PaintFlags::kFill_Style);
+    cc::PaintFlags flags;
+    flags.setAntiAlias(true);
+    flags.setStyle(cc::PaintFlags::kFill_Style);
     if (state == kDisabled)
-      paint.setColor(kRadioDotDisabledColor);
+      flags.setColor(kRadioDotDisabledColor);
     else
-      paint.setColor(kRadioDotColor);
+      flags.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);
+    canvas->drawRoundRect(skrect, radius, radius, flags);
   }
 }
 
 void NativeThemeBase::PaintButton(cc::PaintCanvas* canvas,
                                   State state,
                                   const gfx::Rect& rect,
                                   const ButtonExtraParams& button) const {
-  cc::PaintFlags paint;
+  cc::PaintFlags flags;
   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);
+    flags.setColor(base_color);
+    canvas->drawRect(skrect, flags);
     return;
   }
 
-  paint.setColor(SK_ColorBLACK);
+  flags.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(cc::PaintFlags::kFill_Style);
-  paint.setAntiAlias(true);
-  paint.setShader(cc::WrapSkShader(SkGradientShader::MakeLinear(
+  flags.setStyle(cc::PaintFlags::kFill_Style);
+  flags.setAntiAlias(true);
+  flags.setShader(cc::WrapSkShader(SkGradientShader::MakeLinear(
       gradient_bounds, colors, NULL, 2, SkShader::kClamp_TileMode)));
 
-  canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), paint);
-  paint.setShader(NULL);
+  canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), flags);
+  flags.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));
+      flags.setColor(GetSystemColor(kColorId_FocusedBorderColor));
     }
-    paint.setStyle(cc::PaintFlags::kStroke_Style);
-    paint.setStrokeWidth(SkIntToScalar(1));
-    paint.setAlpha(border_alpha);
+    flags.setStyle(cc::PaintFlags::kStroke_Style);
+    flags.setStrokeWidth(SkIntToScalar(1));
+    flags.setAlpha(border_alpha);
     skrect.inset(SkFloatToScalar(.5f), SkFloatToScalar(.5f));
-    canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), paint);
+    canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), flags);
   }
 }
 
 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);
 
-  cc::PaintFlags fill_paint;
-  fill_paint.setStyle(cc::PaintFlags::kFill_Style);
-  fill_paint.setColor(text.background_color);
-  canvas->drawRect(bounds, fill_paint);
+  cc::PaintFlags fill_flags;
+  fill_flags.setStyle(cc::PaintFlags::kFill_Style);
+  fill_flags.setColor(text.background_color);
+  canvas->drawRect(bounds, fill_flags);
 
   // Text INPUT, listbox SELECT, and TEXTAREA have consistent borders.
   // border: 1px solid #a9a9a9
-  cc::PaintFlags stroke_paint;
-  stroke_paint.setStyle(cc::PaintFlags::kStroke_Style);
-  stroke_paint.setColor(kTextBorderColor);
-  canvas->drawRect(bounds, stroke_paint);
+  cc::PaintFlags stroke_flags;
+  stroke_flags.setStyle(cc::PaintFlags::kStroke_Style);
+  stroke_flags.setColor(kTextBorderColor);
+  canvas->drawRect(bounds, stroke_flags);
 }
 
 void NativeThemeBase::PaintMenuList(
     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);
   }
 
-  cc::PaintFlags paint;
-  paint.setColor(menu_list.arrow_color);
-  paint.setAntiAlias(true);
-  paint.setStyle(cc::PaintFlags::kFill_Style);
+  cc::PaintFlags flags;
+  flags.setColor(menu_list.arrow_color);
+  flags.setAntiAlias(true);
+  flags.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);
+  canvas->drawPath(path, flags);
 }
 
 void NativeThemeBase::PaintMenuPopupBackground(
     cc::PaintCanvas* canvas,
     const gfx::Size& size,
     const MenuBackgroundExtraParams& menu_background) const {
   canvas->drawColor(kMenuPopupBackgroundColor, SkBlendMode::kSrc);
 }
 
 void NativeThemeBase::PaintMenuItemBackground(
     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(
     cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const MenuSeparatorExtraParams& menu_separator) const {
-  cc::PaintFlags paint;
-  paint.setColor(GetSystemColor(ui::NativeTheme::kColorId_MenuSeparatorColor));
-  canvas->drawRect(gfx::RectToSkRect(*menu_separator.paint_rect), paint);
+  cc::PaintFlags flags;
+  flags.setColor(GetSystemColor(ui::NativeTheme::kColorId_MenuSeparatorColor));
+  canvas->drawRect(gfx::RectToSkRect(*menu_separator.paint_rect), flags);
 }
 
 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;
 
-  cc::PaintFlags paint;
-  paint.setColor(kSliderTrackBackgroundColor);
+  cc::PaintFlags flags;
+  flags.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);
+  canvas->drawRect(skrect, flags);
 }
 
 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;
 
-  cc::PaintFlags paint;
-  paint.setColor(hovered ? SK_ColorWHITE : kSliderThumbLightGrey);
+  cc::PaintFlags flags;
+  flags.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);
+  canvas->drawIRect(skrect, flags);
 
-  paint.setColor(hovered ? kSliderThumbLightGrey : kSliderThumbDarkGrey);
+  flags.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);
+  canvas->drawIRect(skrect, flags);
 
-  paint.setColor(kSliderThumbBorderDarkGrey);
-  DrawBox(canvas, rect, paint);
+  flags.setColor(kSliderThumbBorderDarkGrey);
+  DrawBox(canvas, rect, flags);
 
   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);
+    DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY, flags);
+    DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY - 3, flags);
+    DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY + 3, flags);
   }
 }
 
 void NativeThemeBase::PaintInnerSpinButton(
     cc::PaintCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const InnerSpinButtonExtraParams& spin_button) const {
   if (spin_button.read_only)
     state = kDisabled;
@@ skipping 26 matching lines @@
   // 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());
   }
-  cc::PaintFlags stroke_paint;
-  stroke_paint.setColor(kProgressTickColor);
-  stroke_paint.setStyle(cc::PaintFlags::kStroke_Style);
-  stroke_paint.setStrokeWidth(stroke_width);
-  canvas->drawPath(path, stroke_paint);
+  cc::PaintFlags stroke_flags;
+  stroke_flags.setColor(kProgressTickColor);
+  stroke_flags.setStyle(cc::PaintFlags::kStroke_Style);
+  stroke_flags.setStrokeWidth(stroke_width);
+  canvas->drawPath(path, stroke_flags);
 
   // 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);
-  cc::PaintFlags progress_paint;
-  progress_paint.setColor(kProgressValueColor);
-  progress_paint.setStyle(cc::PaintFlags::kFill_Style);
-  canvas->drawRect(gfx::RectToSkRect(progress_rect), progress_paint);
+  cc::PaintFlags progress_flags;
+  progress_flags.setColor(kProgressValueColor);
+  progress_flags.setStyle(cc::PaintFlags::kFill_Style);
+  canvas->drawRect(gfx::RectToSkRect(progress_rect), progress_flags);
 
   // 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);
+  stroke_flags.setColor(kProgressBorderColor);
+  canvas->drawRect(gfx::RectFToSkRect(border_rect), stroke_flags);
 }
 
 void NativeThemeBase::PaintFrameTopArea(
     SkCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const FrameTopAreaExtraParams& frame_top_area) const {
-  SkPaint paint;
-  paint.setColor(frame_top_area.default_background_color);
-  canvas->drawRect(gfx::RectToSkRect(rect), paint);
+  SkPaint flags;
+  flags.setColor(frame_top_area.default_background_color);
+  canvas->drawRect(gfx::RectToSkRect(rect), flags);
 }
 
 void NativeThemeBase::AdjustCheckboxRadioRectForPadding(SkRect* rect) const {
   // By default we only take 1px from right and bottom for the drop shadow.
   rect->iset(rect->x(), rect->y(), rect->right() - 1, rect->bottom() - 1);
 }
 
 SkColor NativeThemeBase::SaturateAndBrighten(SkScalar* hsv,
                                              SkScalar saturate_amount,
                                              SkScalar brighten_amount) const {
@@ skipping 12 matching lines @@
   SkColorToHSV(track_color_, track_hsv);
   SkScalar thumb_hsv[3];
   SkColorToHSV(thumb_inactive_color_, thumb_hsv);
   return OutlineColor(track_hsv, thumb_hsv);
 }
 
 void NativeThemeBase::DrawVertLine(cc::PaintCanvas* canvas,
                                    int x,
                                    int y1,
                                    int y2,
-                                   const cc::PaintFlags& paint) const {
+                                   const cc::PaintFlags& flags) const {
   SkIRect skrect;
   skrect.set(x, y1, x + 1, y2 + 1);
-  canvas->drawIRect(skrect, paint);
+  canvas->drawIRect(skrect, flags);
 }
 
 void NativeThemeBase::DrawHorizLine(cc::PaintCanvas* canvas,
                                     int x1,
                                     int x2,
                                     int y,
-                                    const cc::PaintFlags& paint) const {
+                                    const cc::PaintFlags& flags) const {
   SkIRect skrect;
   skrect.set(x1, y, x2 + 1, y + 1);
-  canvas->drawIRect(skrect, paint);
+  canvas->drawIRect(skrect, flags);
 }
 
 void NativeThemeBase::DrawBox(cc::PaintCanvas* canvas,
                               const gfx::Rect& rect,
-                              const cc::PaintFlags& paint) const {
+                              const cc::PaintFlags& flags) 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);
+  DrawHorizLine(canvas, rect.x(), right, rect.y(), flags);
+  DrawVertLine(canvas, right, rect.y(), bottom, flags);
+  DrawHorizLine(canvas, rect.x(), right, bottom, flags);
+  DrawVertLine(canvas, rect.x(), rect.y(), bottom, flags);
 }
 
 SkScalar NativeThemeBase::Clamp(SkScalar value,
                                 SkScalar min,
                                 SkScalar max) const {
   return std::min(std::max(value, min), max);
 }
 
 SkColor NativeThemeBase::OutlineColor(SkScalar* hsv1, SkScalar* hsv2) const {
   // GTK Theme engines have way too much control over the layout of
@@ skipping 26 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