Clean up naming of paint-related identifiers

chrome/browser/ui/views/tabs/tab.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 "chrome/browser/ui/views/tabs/tab.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 199 matching lines @@
 // stroke inner edge is (GetUnscaledEndcapWidth() * scale) + 1.
 float GetUnscaledEndcapWidth() {
   return GetLayoutInsets(TAB).left() - 0.5f;
 }
 
 void DrawHighlight(gfx::Canvas* canvas,
                    const SkPoint& p,
                    SkScalar radius,
                    SkColor color) {
   const SkColor colors[2] = { color, SkColorSetA(color, 0) };
-  cc::PaintFlags paint;
-  paint.setAntiAlias(true);
-  paint.setShader(cc::WrapSkShader(SkGradientShader::MakeRadial(
+  cc::PaintFlags flags;
+  flags.setAntiAlias(true);
+  flags.setShader(cc::WrapSkShader(SkGradientShader::MakeRadial(
       p, radius, colors, nullptr, 2, SkShader::kClamp_TileMode)));
   canvas->sk_canvas()->drawRect(
       SkRect::MakeXYWH(p.x() - radius, p.y() - radius, radius * 2, radius * 2),
-      paint);
+      flags);
 }
 
 // Returns whether the favicon for the given URL should be colored according to
 // the browser theme.
 bool ShouldThemifyFaviconForUrl(const GURL& url) {
   return url.SchemeIs(content::kChromeUIScheme) &&
          url.host() != chrome::kChromeUIHelpHost &&
          url.host() != chrome::kChromeUIUberHost &&
          url.host() != chrome::kChromeUIAppLauncherPageHost;
 }
@@ skipping 1042 matching lines @@
   }
   canvas->DrawImageInt(it->stroke_image, 0, 0);
 }
 
 void Tab::PaintTabBackgroundUsingFillId(gfx::Canvas* fill_canvas,
                                         gfx::Canvas* stroke_canvas,
                                         bool is_active,
                                         int fill_id,
                                         int y_offset) {
   gfx::Path fill;
-  cc::PaintFlags paint;
-  paint.setAntiAlias(true);
+  cc::PaintFlags flags;
+  flags.setAntiAlias(true);
 
   // Draw the fill.
   {
     gfx::ScopedCanvas scoped_canvas(fill_canvas);
     const float scale = fill_canvas->UndoDeviceScaleFactor();
     const ui::ThemeProvider* tp = GetThemeProvider();
     const SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
 
     fill = GetFillPath(scale, size());
     {
       gfx::ScopedCanvas clip_scoper(fill_canvas);
       fill_canvas->ClipPath(fill, true);
       if (fill_id) {
         gfx::ScopedCanvas scale_scoper(fill_canvas);
         fill_canvas->sk_canvas()->scale(scale, scale);
         fill_canvas->TileImageInt(*tp->GetImageSkiaNamed(fill_id),
                                   GetMirroredX() + background_offset_.x(),
                                   y_offset, 0, 0, width(), height());
       } else {
-        paint.setColor(
+        flags.setColor(
             is_active ? toolbar_color
                       : tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
         fill_canvas->DrawRect(
-            gfx::ScaleToEnclosingRect(GetLocalBounds(), scale), paint);
+            gfx::ScaleToEnclosingRect(GetLocalBounds(), scale), flags);
       }
 
       if (!is_active && hover_controller_.ShouldDraw()) {
         SkPoint hover_location(
             gfx::PointToSkPoint(hover_controller_.location()));
         hover_location.scale(SkFloatToScalar(scale));
         const SkScalar kMinHoverRadius = 16;
         const SkScalar radius =
             std::max(SkFloatToScalar(width() / 4.f), kMinHoverRadius);
         DrawHighlight(fill_canvas, hover_location, radius * scale,
                       SkColorSetA(toolbar_color, hover_controller_.GetAlpha()));
       }
     }
   }
 
   // Draw the stroke.
   {
     gfx::ScopedCanvas scoped_canvas(stroke_canvas);
     const float scale = stroke_canvas->UndoDeviceScaleFactor();
 
     gfx::Path stroke = GetBorderPath(scale, false, false, size());
     Op(stroke, fill, kDifference_SkPathOp, &stroke);
     if (!is_active) {
       // Clip out the bottom line; this will be drawn for us by
       // TabStrip::PaintChildren().
       stroke_canvas->ClipRect(
           gfx::RectF(width() * scale, height() * scale - 1));
     }
-    paint.setColor(controller_->GetToolbarTopSeparatorColor());
-    stroke_canvas->DrawPath(stroke, paint);
+    flags.setColor(controller_->GetToolbarTopSeparatorColor());
+    stroke_canvas->DrawPath(stroke, flags);
   }
 }
 
 void Tab::PaintPinnedTabTitleChangedIndicatorAndIcon(
     gfx::Canvas* canvas,
     const gfx::Rect& favicon_draw_bounds) {
   // The pinned tab title changed indicator consists of two parts:
   // . a clear (totally transparent) part over the bottom right (or left in rtl)
   //   of the favicon. This is done by drawing the favicon to a canvas, then
   //   drawing the clear part on top of the favicon.
   // . a circle in the bottom right (or left in rtl) of the favicon.
   if (!favicon_.isNull()) {
     const float kIndicatorCropRadius = 4.5;
     gfx::Canvas icon_canvas(gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize),
                             canvas->image_scale(), false);
     icon_canvas.DrawImageInt(favicon_, 0, 0);
-    cc::PaintFlags clear_paint;
-    clear_paint.setAntiAlias(true);
-    clear_paint.setBlendMode(SkBlendMode::kClear);
+    cc::PaintFlags clear_flags;
+    clear_flags.setAntiAlias(true);
+    clear_flags.setBlendMode(SkBlendMode::kClear);
     const int circle_x = base::i18n::IsRTL() ? 0 : gfx::kFaviconSize;
     icon_canvas.DrawCircle(gfx::PointF(circle_x, gfx::kFaviconSize),
-                           kIndicatorCropRadius, clear_paint);
+                           kIndicatorCropRadius, clear_flags);
     canvas->DrawImageInt(gfx::ImageSkia(icon_canvas.ExtractImageRep()), 0, 0,
                          favicon_draw_bounds.width(),
                          favicon_draw_bounds.height(), favicon_draw_bounds.x(),
                          favicon_draw_bounds.y(), favicon_draw_bounds.width(),
                          favicon_draw_bounds.height(), false);
   }
 
   // Draws the actual pinned tab title changed indicator.
   const int kIndicatorRadius = 3;
-  cc::PaintFlags indicator_paint;
-  indicator_paint.setColor(GetNativeTheme()->GetSystemColor(
+  cc::PaintFlags indicator_flags;
+  indicator_flags.setColor(GetNativeTheme()->GetSystemColor(
       ui::NativeTheme::kColorId_ProminentButtonColor));
-  indicator_paint.setAntiAlias(true);
+  indicator_flags.setAntiAlias(true);
   const int indicator_x = GetMirroredXWithWidthInView(
       favicon_bounds_.right() - kIndicatorRadius, kIndicatorRadius * 2);
   const int indicator_y = favicon_bounds_.bottom() - kIndicatorRadius;
   canvas->DrawCircle(gfx::Point(indicator_x + kIndicatorRadius,
                                 indicator_y + kIndicatorRadius),
-                     kIndicatorRadius, indicator_paint);
+                     kIndicatorRadius, indicator_flags);
 }
 
 void Tab::PaintIcon(gfx::Canvas* canvas) {
   gfx::Rect bounds = favicon_bounds_;
   bounds.set_x(GetMirroredXForRect(bounds));
   bounds.Offset(0, favicon_hiding_offset_);
   bounds.Intersect(GetContentsBounds());
   if (bounds.IsEmpty())
     return;
 
@@ skipping 189 matching lines @@
   SchedulePaintInRect(bounds);
 }
 
 gfx::Rect Tab::GetImmersiveBarRect() const {
   // The main bar is as wide as the normal tab's horizontal top line.
   gfx::Rect contents = GetContentsBounds();
   contents.set_y(0);
   contents.set_height(kImmersiveBarHeight);
   return contents;
 }