ui: Clean up naming of paint-related identifiers

ui/gfx/render_text.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/gfx/render_text.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <climits>
@@ skipping 205 matching lines @@
 // Value of |underline_thickness_| that indicates that underline metrics have
 // not been set explicitly.
 const SkScalar kUnderlineMetricsNotSet = -1.0f;
 
 SkiaTextRenderer::SkiaTextRenderer(Canvas* canvas)
     : canvas_(canvas),
       canvas_skia_(canvas->sk_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,
                                            SkScalar position) {
   underline_thickness_ = thickness;
   underline_position_ = position;
 }
 
 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,
                                        bool strike, bool diagonal_strike) {
   if (underline)
     DrawUnderline(x, y, width);
   if (strike)
     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();
   }
 }
 
 void SkiaTextRenderer::EndDiagonalStrike() {
   if (diagonal_) {
     diagonal_->Draw();
     diagonal_.reset();
   }
 }
 
 void SkiaTextRenderer::DrawUnderline(int x, int y, int width) {
   SkScalar x_scalar = SkIntToScalar(x);
   SkRect r = SkRect::MakeLTRB(
       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() {
 }
 
 void SkiaTextRenderer::DiagonalStrike::AddPiece(int length, SkColor color) {
   pieces_.push_back(Piece(length, color));
   total_length_ += length;
 }
 
 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);
   const int height = SkScalarCeilToInt(text_size - offset);
   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();
       canvas_->ClipRect(
           Rect(x, end.y() - thickness, pieces_[i].first, clip_height));
     }
 
-    canvas_->DrawLine(start_, end, paint_);
+    canvas_->DrawLine(start_, end, flags_);
 
     if (clipped)
       canvas_->Restore();
 
     x += pieces_[i].first;
   }
 }
 
 StyleIterator::StyleIterator(const BreakList<SkColor>& colors,
                              const BreakList<BaselineStyle>& baselines,
@@ skipping 34 matching lines @@
 LineSegment::~LineSegment() {}
 
 Line::Line() : preceding_heights(0), baseline(0) {}
 
 Line::Line(const Line& other) = default;
 
 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
 
 // static
 constexpr base::char16 RenderText::kPasswordReplacementChar;
 constexpr bool RenderText::kDragToEndIfOutsideVerticalBounds;
 
 RenderText::~RenderText() {
 }
@@ skipping 1291 matching lines @@
 
   for (; range_max < length; ++range_max)
     if (iter.IsEndOfWord(range_max) || iter.IsStartOfWord(range_max))
       break;
 
   return range.is_reversed() ? Range(range_max, range_min)
                              : Range(range_min, range_max);
 }
 
 }  // namespace gfx