Fix cc/paint skia type mismatches

chrome/browser/chromeos/display/touch_calibrator/touch_calibrator_view.cc

 // Copyright 2016 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/chromeos/display/touch_calibrator/touch_calibrator_view.h"
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/resources/vector_icons/vector_icons.h"
 #include "ash/shell.h"
@@ skipping 133 matching lines @@
 
   // Current radius of the outer circle.
   int outer_radius_;
 
   // Minimum radius for outer animated circle.
   const int smallest_radius_animated_circle_;
 
   // Maximum radius for outer animated circle.
   const int largest_radius_animated_circle_;
 
-  SkPaint inner_circle_paint_;
-  SkPaint outer_circle_paint_;
+  cc::PaintFlags inner_circle_flags_;
+  cc::PaintFlags outer_circle_flags_;
 
   std::unique_ptr<gfx::ThrobAnimation> animation_;
 
   // Center of the concentric circles.
   const gfx::Point center_;
 
   DISALLOW_COPY_AND_ASSIGN(CircularThrobberView);
 };
 
 CircularThrobberView::CircularThrobberView(int width,
                                            const SkColor& inner_circle_color,
                                            const SkColor& outer_circle_color,
                                            int animation_duration)
     : inner_radius_(width / 4),
       outer_radius_(inner_radius_),
       smallest_radius_animated_circle_(width * kThrobberCircleRadiusFactor),
       largest_radius_animated_circle_(width / 2),
       center_(gfx::Point(width / 2, width / 2)) {
   SetSize(gfx::Size(width, width));
 
-  inner_circle_paint_.setColor(inner_circle_color);
-  inner_circle_paint_.setStyle(SkPaint::kFill_Style);
-  inner_circle_paint_.setFlags(SkPaint::kAntiAlias_Flag);
+  inner_circle_flags_.setColor(inner_circle_color);
+  inner_circle_flags_.setAntiAlias(true);
+  inner_circle_flags_.setStyle(cc::PaintFlags::kFill_Style);
 
-  outer_circle_paint_.setColor(outer_circle_color);
-  outer_circle_paint_.setStyle(SkPaint::kFill_Style);
-  outer_circle_paint_.setFlags(SkPaint::kAntiAlias_Flag);
+  outer_circle_flags_.setColor(outer_circle_color);
+  outer_circle_flags_.setAntiAlias(true);
+  outer_circle_flags_.setStyle(cc::PaintFlags::kFill_Style);
 
   animation_.reset(new gfx::ThrobAnimation(this));
   animation_->SetThrobDuration(animation_duration);
   animation_->StartThrobbing(-1);
 
   SchedulePaint();
 }
 
 CircularThrobberView::~CircularThrobberView() {}
 
 void CircularThrobberView::OnPaint(gfx::Canvas* canvas) {
-  canvas->DrawCircle(center_, outer_radius_, outer_circle_paint_);
-  canvas->DrawCircle(center_, inner_radius_, inner_circle_paint_);
+  canvas->DrawCircle(center_, outer_radius_, outer_circle_flags_);
+  canvas->DrawCircle(center_, inner_radius_, inner_circle_flags_);
 }
 
 void CircularThrobberView::AnimationProgressed(
     const gfx::Animation* animation) {
   if (animation != animation_.get())
     return;
   outer_radius_ = animation->CurrentValueBetween(
       smallest_radius_animated_circle_, largest_radius_animated_circle_);
   SchedulePaint();
 }
@@ skipping 90 matching lines @@
   int horizontal_offset_;
 
   gfx::Rect rounded_rect_bounds_;
 
   gfx::FontList label_font_list_;
   gfx::FontList sublabel_font_list_;
 
   gfx::Rect label_text_bounds_;
   gfx::Rect sublabel_text_bounds_;
 
-  SkPaint paint_;
+  cc::PaintFlags flags_;
 
   DISALLOW_COPY_AND_ASSIGN(HintBox);
 };
 
 HintBox::HintBox(const gfx::Rect& bounds, int border_radius)
     : border_radius_(border_radius) {
   SetBorder(base::MakeUnique<views::BubbleBorder>(
       base::i18n::IsRTL() ? views::BubbleBorder::RIGHT_CENTER
                           : views::BubbleBorder::LEFT_CENTER,
       views::BubbleBorder::NO_SHADOW_OPAQUE_BORDER, SK_ColorWHITE));
 
   arrow_width_ = (GetInsets().right() - GetInsets().left()) *
                  (base::i18n::IsRTL() ? 1 : -1);
 
   // Border on all sides are the same except on the side of the arrow, in which
   // case the width of the arrow is additional.
   base_border_ = base::i18n::IsRTL() ? GetInsets().left() : GetInsets().right();
 
   SetBounds(bounds.x(), bounds.y() - base_border_,
             bounds.width() + 2 * base_border_ + arrow_width_,
             bounds.height() + 2 * base_border_);
 
   rounded_rect_bounds_ = GetLocalBounds();
   rounded_rect_bounds_.Inset(GetInsets());
 
-  paint_.setColor(SK_ColorWHITE);
-  paint_.setStyle(SkPaint::kFill_Style);
-  paint_.setFlags(SkPaint::kAntiAlias_Flag);
+  flags_.setColor(SK_ColorWHITE);
+  flags_.setStyle(cc::PaintFlags::kFill_Style);
+  flags_.setAntiAlias(true);
 
   horizontal_offset_ =
       arrow_width_ + base_border_ + rounded_rect_bounds_.width() * 0.08f;
   int top_offset = horizontal_offset_;
   int line_gap = rounded_rect_bounds_.height() * 0.018f;
   int label_height = rounded_rect_bounds_.height() * 0.11f;
 
   label_text_bounds_.SetRect(horizontal_offset_, top_offset, 0, label_height);
 
   top_offset += label_text_bounds_.height() + line_gap;
@@ skipping 47 matching lines @@
 
   // Check if the width of hint box needs to be updated.
   int minimum_expected_width =
       size.width() + 2 * horizontal_offset_ - arrow_width_;
   if (minimum_expected_width > rounded_rect_bounds_.width())
     UpdateWidth(minimum_expected_width);
 }
 
 void HintBox::OnPaint(gfx::Canvas* canvas) {
   views::View::OnPaint(canvas);
-  canvas->DrawRoundRect(rounded_rect_bounds_, border_radius_, paint_);
+  canvas->DrawRoundRect(rounded_rect_bounds_, border_radius_, flags_);
   canvas->DrawStringRectWithFlags(label_text_, label_font_list_, label_color_,
                                   label_text_bounds_, gfx::Canvas::NO_ELLIPSIS);
   canvas->DrawStringRectWithFlags(sublabel_text_, sublabel_font_list_,
                                   sublabel_color_, sublabel_text_bounds_,
                                   gfx::Canvas::NO_ELLIPSIS);
 }
 
 class CompletionMessageView : public views::View {
  public:
   CompletionMessageView(const gfx::Rect& bounds, const base::string16& message);
   ~CompletionMessageView() override;
 
   // views::View overrides:
   void OnPaint(gfx::Canvas* canvas) override;
 
  private:
   const base::string16 message_;
   gfx::FontList font_list_;
 
   gfx::Rect text_bounds_;
 
   gfx::ImageSkia check_icon_;
 
-  SkPaint paint_;
+  cc::PaintFlags flags_;
 
   DISALLOW_COPY_AND_ASSIGN(CompletionMessageView);
 };
 
 CompletionMessageView::CompletionMessageView(const gfx::Rect& bounds,
                                              const base::string16& message)
     : message_(message) {
   SetBoundsRect(bounds);
 
   int x_offset = height() * 5.f / 4.f;
   text_bounds_.SetRect(x_offset, 0, width() - x_offset, height());
 
   font_list_ = ui::ResourceBundle::GetSharedInstance().GetFontListWithDelta(
       kCompleteMessageTextSize, gfx::Font::FontStyle::NORMAL,
       gfx::Font::Weight::NORMAL);
 
   // crbug/676513 moves this file to src/ash which will require an ash icon
   // file.
   check_icon_ = gfx::CreateVectorIcon(ash::kTouchCalibrationCompleteCheckIcon,
                                       SK_ColorWHITE);
 
-  paint_.setColor(SK_ColorWHITE);
-  paint_.setStyle(SkPaint::kFill_Style);
-  paint_.setFlags(SkPaint::kAntiAlias_Flag);
+  flags_.setColor(SK_ColorWHITE);
+  flags_.setStyle(cc::PaintFlags::kFill_Style);
+  flags_.setAntiAlias(true);
 }
 
 CompletionMessageView::~CompletionMessageView() {}
 
 void CompletionMessageView::OnPaint(gfx::Canvas* canvas) {
   canvas->DrawImageInt(check_icon_, 0, 0);
 
   // TODO(malaykeshav): Work with elizabethchiu@ to get better UX for RTL.
   canvas->DrawStringRectWithFlags(
-      message_, font_list_, paint_.getColor(), text_bounds_,
+      message_, font_list_, flags_.getColor(), text_bounds_,
       gfx::Canvas::TEXT_ALIGN_LEFT | gfx::Canvas::NO_SUBPIXEL_RENDERING);
 }
 
 TouchCalibratorView::TouchCalibratorView(const display::Display& target_display,
                                          bool is_primary_view)
     : display_(target_display),
       is_primary_view_(is_primary_view),
       exit_label_(nullptr),
       tap_label_(nullptr),
       throbber_circle_(nullptr),
@@ skipping 157 matching lines @@
   // If current state is a fade in or fade out state then update opacity
   // based on how far the animation has progressed.
   if (animator_ && (state_ == TouchCalibratorView::BACKGROUND_FADING_OUT ||
                     state_ == TouchCalibratorView::BACKGROUND_FADING_IN)) {
     opacity = static_cast<float>(animator_->CurrentValueBetween(
         start_opacity_value_, end_opacity_value_));
   } else {
     opacity = state_ == BACKGROUND_FADING_OUT ? 0.f : kBackgroundFinalOpacity;
   }
 
-  paint_.setColor(SkColorSetA(SK_ColorBLACK,
+  flags_.setColor(SkColorSetA(SK_ColorBLACK,
                               std::numeric_limits<uint8_t>::max() * opacity));
-  canvas->DrawRect(background_rect_, paint_);
+  canvas->DrawRect(background_rect_, flags_);
 }
 
 void TouchCalibratorView::AnimationProgressed(const gfx::Animation* animation) {
   if (!is_primary_view_) {
     SchedulePaint();
     return;
   }
 }
 
 void TouchCalibratorView::AnimationCanceled(const gfx::Animation* animation) {
@@ skipping 57 matching lines @@
   // Stop any previous animations and skip them to the end.
   SkipCurrentAnimation();
 
   switch (state_) {
     case UNKNOWN:
     case BACKGROUND_FADING_IN:
       state_ = BACKGROUND_FADING_IN;
       start_opacity_value_ = 0.f;
       end_opacity_value_ = kBackgroundFinalOpacity;
 
-      paint_.setStyle(SkPaint::kFill_Style);
+      flags_.setStyle(cc::PaintFlags::kFill_Style);
       animator_->SetDuration(kFadeDurationInMs);
       animator_->Start();
       return;
     case DISPLAY_POINT_1:
       state_ = ANIMATING_1_TO_2;
 
       // The touch point has to be animated from the top left corner of the
       // screen to the top right corner.
       AnimateLayerToPosition(
           touch_point_view_, kPointMoveDurationInMs,
@@ skipping 45 matching lines @@
             completion_message_view_, kFadeDurationInMs,
             gfx::Point(completion_message_view_->x(),
                        completion_message_view_->y() +
                            2 * completion_message_view_->height()),
             0.f);
       }
 
       start_opacity_value_ = kBackgroundFinalOpacity;
       end_opacity_value_ = 0.f;
 
-      paint_.setStyle(SkPaint::kFill_Style);
+      flags_.setStyle(cc::PaintFlags::kFill_Style);
       animator_->SetDuration(kFadeDurationInMs);
       animator_->Start();
       return;
     default:
       return;
   }
 }
 
 bool TouchCalibratorView::GetDisplayPointLocation(gfx::Point* location) {
   DCHECK(location);
@@ skipping 29 matching lines @@
 void TouchCalibratorView::SkipCurrentAnimation() {
   if (animator_->is_animating())
     animator_->End();
   if (touch_point_view_ &&
       touch_point_view_->layer()->GetAnimator()->is_animating()) {
     touch_point_view_->layer()->GetAnimator()->StopAnimating();
   }
 }
 
 }  // namespace chromeos