ui: Clean up naming of paint-related identifiers

ui/native_theme/native_theme_win.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_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <uxtheme.h>
 #include <vsstyle.h>
@@ skipping 42 matching lines @@
   COLOR_GRAYTEXT,
   COLOR_HIGHLIGHT,
   COLOR_HIGHLIGHTTEXT,
   COLOR_HOTLIGHT,
   COLOR_MENUHIGHLIGHT,
   COLOR_SCROLLBAR,
   COLOR_WINDOW,
   COLOR_WINDOWTEXT,
 };
 
-void SetCheckerboardShader(cc::PaintFlags* paint, const RECT& align_rect) {
+void SetCheckerboardShader(cc::PaintFlags* flags, const RECT& align_rect) {
   // Create a 2x2 checkerboard pattern using the 3D face and highlight colors.
   const SkColor face = color_utils::GetSysSkColor(COLOR_3DFACE);
   const SkColor highlight = color_utils::GetSysSkColor(COLOR_3DHILIGHT);
   SkColor buffer[] = { face, highlight, highlight, face };
   // Confusing bit: we first create a temporary bitmap with our desired pattern,
   // then copy it to another bitmap.  The temporary bitmap doesn't take
   // ownership of the pixel data, and so will point to garbage when this
   // function returns.  The copy will copy the pixel data into a place owned by
   // the bitmap, which is in turn owned by the shader, etc., so it will live
   // until we're done using it.
   SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
   SkBitmap temp_bitmap;
   temp_bitmap.installPixels(info, buffer, info.minRowBytes());
   SkBitmap bitmap;
   temp_bitmap.copyTo(&bitmap);
 
   // Align the pattern with the upper corner of |align_rect|.
   SkMatrix local_matrix;
   local_matrix.setTranslate(SkIntToScalar(align_rect.left),
                             SkIntToScalar(align_rect.top));
-  paint->setShader(
+  flags->setShader(
       SkShader::MakeBitmapShader(bitmap, SkShader::kRepeat_TileMode,
                                  SkShader::kRepeat_TileMode, &local_matrix));
 }
 
 //    <-a->
 // [  *****             ]
 //  ____ |              |
 //  <-a-> <------b----->
 // a: object_width
 // b: frame_width
@@ skipping 276 matching lines @@
   NotifyObservers();
 }
 
 void NativeThemeWin::UpdateSystemColors() {
   for (int kSystemColor : kSystemColors)
     system_colors_[kSystemColor] = color_utils::GetSysSkColor(kSystemColor);
 }
 
 void NativeThemeWin::PaintMenuSeparator(SkCanvas* canvas,
                                         const gfx::Rect& rect) const {
-  cc::PaintFlags paint;
-  paint.setColor(GetSystemColor(NativeTheme::kColorId_MenuSeparatorColor));
+  cc::PaintFlags flags;
+  flags.setColor(GetSystemColor(NativeTheme::kColorId_MenuSeparatorColor));
   int position_y = rect.y() + rect.height() / 2;
-  canvas->drawLine(rect.x(), position_y, rect.right(), position_y, paint);
+  canvas->drawLine(rect.x(), position_y, rect.right(), position_y, flags);
 }
 
 void NativeThemeWin::PaintMenuGutter(SkCanvas* canvas,
                                      const gfx::Rect& rect) const {
-  cc::PaintFlags paint;
-  paint.setColor(GetSystemColor(NativeTheme::kColorId_MenuSeparatorColor));
+  cc::PaintFlags flags;
+  flags.setColor(GetSystemColor(NativeTheme::kColorId_MenuSeparatorColor));
   int position_x = rect.x() + rect.width() / 2;
-  canvas->drawLine(position_x, rect.y(), position_x, rect.bottom(), paint);
+  canvas->drawLine(position_x, rect.y(), position_x, rect.bottom(), flags);
 }
 
 void NativeThemeWin::PaintMenuBackground(SkCanvas* canvas,
                                          const gfx::Rect& rect) const {
-  cc::PaintFlags paint;
-  paint.setColor(GetSystemColor(NativeTheme::kColorId_MenuBackgroundColor));
-  canvas->drawRect(gfx::RectToSkRect(rect), paint);
+  cc::PaintFlags flags;
+  flags.setColor(GetSystemColor(NativeTheme::kColorId_MenuBackgroundColor));
+  canvas->drawRect(gfx::RectToSkRect(rect), flags);
 }
 
 void NativeThemeWin::PaintDirect(SkCanvas* destination_canvas,
                                  HDC hdc,
                                  Part part,
                                  State state,
                                  const gfx::Rect& rect,
                                  const ExtraParams& extra) const {
   switch (part) {
     case kCheckbox:
@@ skipping 904 matching lines @@
   }
 
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, part_id, state_id, &rect_win, NULL);
 
   // Draw it manually.
   if ((system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_3DFACE]) &&
       (system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_WINDOW])) {
     FillRect(hdc, &rect_win, reinterpret_cast<HBRUSH>(COLOR_SCROLLBAR + 1));
   } else {
-    cc::PaintFlags paint;
+    cc::PaintFlags flags;
     RECT align_rect = gfx::Rect(extra.track_x, extra.track_y, extra.track_width,
                                 extra.track_height).ToRECT();
-    SetCheckerboardShader(&paint, align_rect);
-    canvas->drawIRect(skia::RECTToSkIRect(rect_win), paint);
+    SetCheckerboardShader(&flags, align_rect);
+    canvas->drawIRect(skia::RECTToSkIRect(rect_win), flags);
   }
   if (extra.classic_state & DFCS_PUSHED)
     InvertRect(hdc, &rect_win);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintSpinButton(
     HDC hdc,
     Part part,
     State state,
@@ skipping 94 matching lines @@
     RECT right_half = bottom_section;
     right_half.left += ((bottom_section.right - bottom_section.left) / 2);
     left_half.right = right_half.left;
     DrawEdge(hdc, &left_half, EDGE_RAISED,
              BF_DIAGONAL_ENDTOPLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
     DrawEdge(hdc, &right_half, EDGE_RAISED,
              BF_DIAGONAL_ENDBOTTOMLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
 
     // If the button is pressed, draw hatching.
     if (extra.classic_state & DFCS_PUSHED) {
-      cc::PaintFlags paint;
-      SetCheckerboardShader(&paint, rect_win);
+      cc::PaintFlags flags;
+      SetCheckerboardShader(&flags, rect_win);
 
       // Fill all three pieces with the pattern.
-      canvas->drawIRect(skia::RECTToSkIRect(top_section), paint);
+      canvas->drawIRect(skia::RECTToSkIRect(top_section), flags);
 
       SkScalar left_triangle_top = SkIntToScalar(left_half.top);
       SkScalar left_triangle_right = SkIntToScalar(left_half.right);
       SkPath left_triangle;
       left_triangle.moveTo(SkIntToScalar(left_half.left), left_triangle_top);
       left_triangle.lineTo(left_triangle_right, left_triangle_top);
       left_triangle.lineTo(left_triangle_right,
                            SkIntToScalar(left_half.bottom));
       left_triangle.close();
-      canvas->drawPath(left_triangle, paint);
+      canvas->drawPath(left_triangle, flags);
 
       SkScalar right_triangle_left = SkIntToScalar(right_half.left);
       SkScalar right_triangle_top = SkIntToScalar(right_half.top);
       SkPath right_triangle;
       right_triangle.moveTo(right_triangle_left, right_triangle_top);
       right_triangle.lineTo(SkIntToScalar(right_half.right),
                             right_triangle_top);
       right_triangle.lineTo(right_triangle_left,
                             SkIntToScalar(right_half.bottom));
       right_triangle.close();
-      canvas->drawPath(right_triangle, paint);
+      canvas->drawPath(right_triangle, flags);
     }
   }
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintProgressBar(
     HDC hdc,
     const gfx::Rect& rect,
     const ProgressBarExtraParams& extra) const {
   // There is no documentation about the animation speed, frame-rate, nor
@@ skipping 624 matching lines @@
     break;
   case LAST:
     NOTREACHED();
     break;
   }
   theme_handles_[theme_name] = handle;
   return handle;
 }
 
 }  // namespace ui