ash: Clean up naming of paint-related identifiers

ash/magnifier/partial_magnification_controller.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 "ash/magnifier/partial_magnification_controller.h"
 
 #include "ash/common/system/chromeos/palette/palette_utils.h"
 #include "ash/shell.h"
 #include "third_party/skia/include/core/SkDrawLooper.h"
 #include "ui/aura/window_event_dispatcher.h"
@@ skipping 87 matching lines @@
 
   ~ContentMask() override { layer_.set_delegate(nullptr); }
 
   ui::Layer* layer() { return &layer_; }
 
  private:
   // ui::LayerDelegate:
   void OnPaintLayer(const ui::PaintContext& context) override {
     ui::PaintRecorder recorder(context, layer()->size());
 
-    cc::PaintFlags paint;
-    paint.setAlpha(255);
-    paint.setAntiAlias(true);
+    cc::PaintFlags flags;
+    flags.setAlpha(255);
+    flags.setAntiAlias(true);
     // Stroke is used for clipping the border which consists of the rendered
     // border |kBorderSize| and the magnifier shadow |kShadowThickness| and
     // |kShadowOffset|.
-    paint.setStrokeWidth(kBorderSize + kShadowThickness + kShadowOffset);
-    paint.setStyle(is_border_ ? cc::PaintFlags::kStroke_Style
+    flags.setStrokeWidth(kBorderSize + kShadowThickness + kShadowOffset);
+    flags.setStyle(is_border_ ? cc::PaintFlags::kStroke_Style
                               : cc::PaintFlags::kFill_Style);
 
     // If we want to clip the magnifier zone use the magnifiers radius.
     // Otherwise we want to clip the border, shadow and shadow offset so we
     // start
     // at the halfway point of the stroke width.
     gfx::Rect rect(layer()->bounds().size());
     int clipping_radius = kMagnifierRadius;
     if (is_border_)
       clipping_radius += (kShadowThickness + kShadowOffset + kBorderSize) / 2;
-    recorder.canvas()->DrawCircle(rect.CenterPoint(), clipping_radius, paint);
+    recorder.canvas()->DrawCircle(rect.CenterPoint(), clipping_radius, flags);
   }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {
     // Redrawing will take care of scale factor change.
   }
 
   ui::Layer layer_;
   bool is_border_;
@@ skipping 15 matching lines @@
   }
 
   ~BorderRenderer() override {}
 
  private:
   // ui::LayerDelegate:
   void OnPaintLayer(const ui::PaintContext& context) override {
     ui::PaintRecorder recorder(context, magnifier_window_bounds_.size());
 
     // Draw the shadow.
-    cc::PaintFlags shadow_paint;
-    shadow_paint.setAntiAlias(true);
-    shadow_paint.setColor(SK_ColorTRANSPARENT);
-    shadow_paint.setLooper(
+    cc::PaintFlags shadow_flags;
+    shadow_flags.setAntiAlias(true);
+    shadow_flags.setColor(SK_ColorTRANSPARENT);
+    shadow_flags.setLooper(
         gfx::CreateShadowDrawLooperCorrectBlur(magnifier_shadows_));
     gfx::Rect shadow_bounds(magnifier_window_bounds_.size());
     recorder.canvas()->DrawCircle(
         shadow_bounds.CenterPoint(),
         shadow_bounds.width() / 2 - kShadowThickness - kShadowOffset,
-        shadow_paint);
+        shadow_flags);
 
-    cc::PaintFlags border_paint;
-    border_paint.setAntiAlias(true);
-    border_paint.setStyle(cc::PaintFlags::kStroke_Style);
+    cc::PaintFlags border_flags;
+    border_flags.setAntiAlias(true);
+    border_flags.setStyle(cc::PaintFlags::kStroke_Style);
 
     // The radius of the magnifier and its border.
     const int magnifier_radius = kMagnifierRadius + kBorderSize;
 
     // Draw the inner border.
-    border_paint.setStrokeWidth(kBorderSize);
-    border_paint.setColor(kBorderColor);
+    border_flags.setStrokeWidth(kBorderSize);
+    border_flags.setColor(kBorderColor);
     recorder.canvas()->DrawCircle(magnifier_window_bounds_.CenterPoint(),
                                   magnifier_radius - kBorderSize / 2,
-                                  border_paint);
+                                  border_flags);
 
     // Draw border outer outline and then draw the border inner outline.
-    border_paint.setStrokeWidth(kBorderOutlineThickness);
-    border_paint.setColor(kBorderOutlineColor);
+    border_flags.setStrokeWidth(kBorderOutlineThickness);
+    border_flags.setColor(kBorderOutlineColor);
     recorder.canvas()->DrawCircle(
         magnifier_window_bounds_.CenterPoint(),
-        magnifier_radius - kBorderOutlineThickness / 2, border_paint);
+        magnifier_radius - kBorderOutlineThickness / 2, border_flags);
     recorder.canvas()->DrawCircle(
         magnifier_window_bounds_.CenterPoint(),
         magnifier_radius - kBorderSize + kBorderOutlineThickness / 2,
-        border_paint);
+        border_flags);
   }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
   gfx::Rect magnifier_window_bounds_;
   std::vector<gfx::ShadowValue> magnifier_shadows_;
 
   DISALLOW_COPY_AND_ASSIGN(BorderRenderer);
@@ skipping 166 matching lines @@
 
 void PartialMagnificationController::RemoveZoomWidgetObservers() {
   DCHECK(host_widget_);
   host_widget_->RemoveObserver(this);
   aura::Window* root_window = host_widget_->GetNativeView()->GetRootWindow();
   DCHECK(root_window);
   root_window->RemoveObserver(this);
 }
 
 }  // namespace ash