ui: Clean up naming of paint-related identifiers

ui/gfx/paint_vector_icon.cc

 // Copyright 2015 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/paint_vector_icon.h"
 
 #include <map>
 #include <tuple>
 
 #include "base/i18n/rtl.h"
@@ skipping 72 matching lines @@
 
 void PaintPath(Canvas* canvas,
                const PathElement* path_elements,
                int dip_size,
                SkColor color) {
   SkPath path;
   path.setFillType(SkPath::kEvenOdd_FillType);
 
   int canvas_size = kReferenceSizeDip;
   std::vector<SkPath> paths;
-  std::vector<cc::PaintFlags> paints;
+  std::vector<cc::PaintFlags> flags_array;
   SkRect clip_rect = SkRect::MakeEmpty();
   bool flips_in_rtl = false;
   CommandType previous_command_type = NEW_PATH;
 
   for (size_t i = 0; path_elements[i].type != END; i++) {
     if (paths.empty() || path_elements[i].type == NEW_PATH) {
       paths.push_back(SkPath());
       paths.back().setFillType(SkPath::kEvenOdd_FillType);
 
-      paints.push_back(cc::PaintFlags());
-      paints.back().setColor(color);
-      paints.back().setAntiAlias(true);
-      paints.back().setStrokeCap(cc::PaintFlags::kRound_Cap);
+      flags_array.push_back(cc::PaintFlags());
+      flags_array.back().setColor(color);
+      flags_array.back().setAntiAlias(true);
+      flags_array.back().setStrokeCap(cc::PaintFlags::kRound_Cap);
     }
 
     SkPath& path = paths.back();
-    cc::PaintFlags& paint = paints.back();
+    cc::PaintFlags& flags = flags_array.back();
     CommandType command_type = path_elements[i].type;
     switch (command_type) {
       // Handled above.
       case NEW_PATH:
         continue;
 
       case PATH_COLOR_ARGB: {
         int a = SkScalarFloorToInt(path_elements[++i].arg);
         int r = SkScalarFloorToInt(path_elements[++i].arg);
         int g = SkScalarFloorToInt(path_elements[++i].arg);
         int b = SkScalarFloorToInt(path_elements[++i].arg);
-        paint.setColor(SkColorSetARGB(a, r, g, b));
+        flags.setColor(SkColorSetARGB(a, r, g, b));
         break;
       }
 
       case PATH_MODE_CLEAR: {
-        paint.setBlendMode(SkBlendMode::kClear);
+        flags.setBlendMode(SkBlendMode::kClear);
         break;
       };
 
       case STROKE: {
-        paint.setStyle(cc::PaintFlags::kStroke_Style);
+        flags.setStyle(cc::PaintFlags::kStroke_Style);
         SkScalar width = path_elements[++i].arg;
-        paint.setStrokeWidth(width);
+        flags.setStrokeWidth(width);
         break;
       }
 
       case CAP_SQUARE: {
-        paint.setStrokeCap(cc::PaintFlags::kSquare_Cap);
+        flags.setStrokeCap(cc::PaintFlags::kSquare_Cap);
         break;
       }
 
       case MOVE_TO: {
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
         path.moveTo(x, y);
         break;
       }
 
@@ skipping 153 matching lines @@
       case CLIP: {
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
         SkScalar w = path_elements[++i].arg;
         SkScalar h = path_elements[++i].arg;
         clip_rect = SkRect::MakeXYWH(x, y, w, h);
         break;
       }
 
       case DISABLE_AA: {
-        paint.setAntiAlias(false);
+        flags.setAntiAlias(false);
         break;
       }
 
       case FLIPS_IN_RTL: {
         flips_in_rtl = true;
         break;
       }
 
       case END:
         NOTREACHED();
         break;
     }
 
     previous_command_type = command_type;
   }
 
   gfx::ScopedRTLFlipCanvas scoped_rtl_flip_canvas(canvas, canvas_size,
                                                   flips_in_rtl);
 
   if (dip_size != canvas_size) {
     SkScalar scale = SkIntToScalar(dip_size) / SkIntToScalar(canvas_size);
     canvas->sk_canvas()->scale(scale, scale);
   }
 
   if (!clip_rect.isEmpty())
     canvas->sk_canvas()->clipRect(clip_rect);
 
-  DCHECK_EQ(paints.size(), paths.size());
+  DCHECK_EQ(flags_array.size(), paths.size());
   for (size_t i = 0; i < paths.size(); ++i)
-    canvas->DrawPath(paths[i], paints[i]);
+    canvas->DrawPath(paths[i], flags_array[i]);
 }
 
 class VectorIconSource : public CanvasImageSource {
  public:
   VectorIconSource(const VectorIcon& icon,
                    int dip_size,
                    SkColor color,
                    const VectorIcon& badge_icon)
       : CanvasImageSource(gfx::Size(dip_size, dip_size), false),
         color_(color),
@@ skipping 241 matching lines @@
 }
 
 ImageSkia CreateVectorIconFromSource(const std::string& source,
                                      int dip_size,
                                      SkColor color) {
   return CanvasImageSource::MakeImageSkia<VectorIconSourceLegacy>(
       source, dip_size, color);
 }
 
 }  // namespace gfx