ui: Clean up naming of paint-related identifiers

ui/gfx/render_text.cc

Index: ui/gfx/render_text.cc
diff --git a/ui/gfx/render_text.cc b/ui/gfx/render_text.cc
index 69c7c0b1b9bbdc73bec61ca6c7d77f8bd177645c..629fb60a670e6c0819d9413a8dba924b3249297f 100644
--- a/ui/gfx/render_text.cc
+++ b/ui/gfx/render_text.cc
@@ -223,44 +223,44 @@ SkiaTextRenderer::SkiaTextRenderer(Canvas* canvas)
       underline_thickness_(kUnderlineMetricsNotSet),
       underline_position_(0.0f) {
   DCHECK(canvas_skia_);
-  paint_.setTextEncoding(cc::PaintFlags::kGlyphID_TextEncoding);
-  paint_.setStyle(cc::PaintFlags::kFill_Style);
-  paint_.setAntiAlias(true);
-  paint_.setSubpixelText(true);
-  paint_.setLCDRenderText(true);
-  paint_.setHinting(cc::PaintFlags::kNormal_Hinting);
+  flags_.setTextEncoding(cc::PaintFlags::kGlyphID_TextEncoding);
+  flags_.setStyle(cc::PaintFlags::kFill_Style);
+  flags_.setAntiAlias(true);
+  flags_.setSubpixelText(true);
+  flags_.setLCDRenderText(true);
+  flags_.setHinting(cc::PaintFlags::kNormal_Hinting);
 }
 
 SkiaTextRenderer::~SkiaTextRenderer() {
 }
 
 void SkiaTextRenderer::SetDrawLooper(sk_sp<SkDrawLooper> draw_looper) {
-  paint_.setLooper(std::move(draw_looper));
+  flags_.setLooper(std::move(draw_looper));
 }
 
 void SkiaTextRenderer::SetFontRenderParams(const FontRenderParams& params,
                                            bool subpixel_rendering_suppressed) {
-  ApplyRenderParams(params, subpixel_rendering_suppressed, &paint_);
+  ApplyRenderParams(params, subpixel_rendering_suppressed, &flags_);
 }
 
 void SkiaTextRenderer::SetTypeface(sk_sp<SkTypeface> typeface) {
-  paint_.setTypeface(std::move(typeface));
+  flags_.setTypeface(std::move(typeface));
 }
 
 void SkiaTextRenderer::SetTextSize(SkScalar size) {
-  paint_.setTextSize(size);
+  flags_.setTextSize(size);
 }
 
 void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
-  paint_.setColor(foreground);
+  flags_.setColor(foreground);
 }
 
 void SkiaTextRenderer::SetShader(sk_sp<SkShader> shader) {
-  paint_.setShader(cc::WrapSkShader(std::move(shader)));
+  flags_.setShader(cc::WrapSkShader(std::move(shader)));
 }
 
 void SkiaTextRenderer::SetHaloEffect() {
-  paint_.setImageFilter(SkDilateImageFilter::Make(1, 1, nullptr));
+  flags_.setImageFilter(SkDilateImageFilter::Make(1, 1, nullptr));
 }
 
 void SkiaTextRenderer::SetUnderlineMetrics(SkScalar thickness,
@@ -273,7 +273,7 @@ void SkiaTextRenderer::DrawPosText(const SkPoint* pos,
                                    const uint16_t* glyphs,
                                    size_t glyph_count) {
   const size_t byte_length = glyph_count * sizeof(glyphs[0]);
-  canvas_skia_->drawPosText(&glyphs[0], byte_length, &pos[0], paint_);
+  canvas_skia_->drawPosText(&glyphs[0], byte_length, &pos[0], flags_);
 }
 
 void SkiaTextRenderer::DrawDecorations(int x, int y, int width, bool underline,
@@ -284,8 +284,8 @@ void SkiaTextRenderer::DrawDecorations(int x, int y, int width, bool underline,
     DrawStrike(x, y, width);
   if (diagonal_strike) {
     if (!diagonal_)
-      diagonal_.reset(new DiagonalStrike(canvas_, Point(x, y), paint_));
-    diagonal_->AddPiece(width, paint_.getColor());
+      diagonal_.reset(new DiagonalStrike(canvas_, Point(x, y), flags_));
+    diagonal_->AddPiece(width, flags_.getColor());
   } else if (diagonal_) {
     EndDiagonalStrike();
   }
@@ -304,27 +304,27 @@ void SkiaTextRenderer::DrawUnderline(int x, int y, int width) {
       x_scalar, y + underline_position_, x_scalar + width,
       y + underline_position_ + underline_thickness_);
   if (underline_thickness_ == kUnderlineMetricsNotSet) {
-    const SkScalar text_size = paint_.getTextSize();
+    const SkScalar text_size = flags_.getTextSize();
     r.fTop = SkScalarMulAdd(text_size, kUnderlineOffset, y);
     r.fBottom = r.fTop + SkScalarMul(text_size, kLineThickness);
   }
-  canvas_skia_->drawRect(r, paint_);
+  canvas_skia_->drawRect(r, flags_);
 }
 
 void SkiaTextRenderer::DrawStrike(int x, int y, int width) const {
-  const SkScalar text_size = paint_.getTextSize();
+  const SkScalar text_size = flags_.getTextSize();
   const SkScalar height = SkScalarMul(text_size, kLineThickness);
   const SkScalar offset = SkScalarMulAdd(text_size, kStrikeThroughOffset, y);
   SkScalar x_scalar = SkIntToScalar(x);
   const SkRect r =
       SkRect::MakeLTRB(x_scalar, offset, x_scalar + width, offset + height);
-  canvas_skia_->drawRect(r, paint_);
+  canvas_skia_->drawRect(r, flags_);
 }
 
 SkiaTextRenderer::DiagonalStrike::DiagonalStrike(Canvas* canvas,
                                                  Point start,
-                                                 const cc::PaintFlags& paint)
-    : canvas_(canvas), start_(start), paint_(paint), total_length_(0) {}
+                                                 const cc::PaintFlags& flags)
+    : canvas_(canvas), start_(start), flags_(flags), total_length_(0) {}
 
 SkiaTextRenderer::DiagonalStrike::~DiagonalStrike() {
 }
@@ -335,7 +335,7 @@ void SkiaTextRenderer::DiagonalStrike::AddPiece(int length, SkColor color) {
 }
 
 void SkiaTextRenderer::DiagonalStrike::Draw() {
-  const SkScalar text_size = paint_.getTextSize();
+  const SkScalar text_size = flags_.getTextSize();
   const SkScalar offset = SkScalarMul(text_size, kDiagonalStrikeMarginOffset);
   const int thickness =
       SkScalarCeilToInt(SkScalarMul(text_size, kLineThickness) * 2);
@@ -343,14 +343,14 @@ void SkiaTextRenderer::DiagonalStrike::Draw() {
   const Point end = start_ + Vector2d(total_length_, -height);
   const int clip_height = height + 2 * thickness;
 
-  paint_.setAntiAlias(true);
-  paint_.setStrokeWidth(SkIntToScalar(thickness));
+  flags_.setAntiAlias(true);
+  flags_.setStrokeWidth(SkIntToScalar(thickness));
 
   const bool clipped = pieces_.size() > 1;
   int x = start_.x();
 
   for (size_t i = 0; i < pieces_.size(); ++i) {
-    paint_.setColor(pieces_[i].second);
+    flags_.setColor(pieces_[i].second);
 
     if (clipped) {
       canvas_->Save();
@@ -358,7 +358,7 @@ void SkiaTextRenderer::DiagonalStrike::Draw() {
           Rect(x, end.y() - thickness, pieces_[i].first, clip_height));
     }
 
-    canvas_->DrawLine(start_, end, paint_);
+    canvas_->DrawLine(start_, end, flags_);
 
     if (clipped)
       canvas_->Restore();
@@ -413,13 +413,14 @@ Line::~Line() {}
 
 void ApplyRenderParams(const FontRenderParams& params,
                        bool subpixel_rendering_suppressed,
-                       cc::PaintFlags* paint) {
-  paint->setAntiAlias(params.antialiasing);
-  paint->setLCDRenderText(!subpixel_rendering_suppressed &&
-      params.subpixel_rendering != FontRenderParams::SUBPIXEL_RENDERING_NONE);
-  paint->setSubpixelText(params.subpixel_positioning);
-  paint->setAutohinted(params.autohinter);
-  paint->setHinting(FontRenderParamsHintingToPaintFlagsHinting(params.hinting));
+                       cc::PaintFlags* flags) {
+  flags->setAntiAlias(params.antialiasing);
+  flags->setLCDRenderText(!subpixel_rendering_suppressed &&
+                          params.subpixel_rendering !=
+                              FontRenderParams::SUBPIXEL_RENDERING_NONE);
+  flags->setSubpixelText(params.subpixel_positioning);
+  flags->setAutohinted(params.autohinter);
+  flags->setHinting(FontRenderParamsHintingToPaintFlagsHinting(params.hinting));
 }
 
 }  // namespace internal