Fix cc/paint skia type mismatches

chrome/browser/ui/views/frame/browser_header_painter_ash.cc

 // Copyright 2014 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/frame/browser_header_painter_ash.h"
 
 #include "ash/common/ash_layout_constants.h"
 #include "ash/common/frame/caption_buttons/frame_caption_button_container_view.h"
 #include "ash/common/frame/header_painter_util.h"
 #include "ash/resources/vector_icons/vector_icons.h"
@@ skipping 42 matching lines @@
   SkPath path;
   path.addRoundRect(rect, radii, SkPath::kCW_Direction);
   return path;
 }
 
 // Tiles |frame_image| and |frame_overlay_image| into an area, rounding the top
 // corners.
 void PaintFrameImagesInRoundRect(gfx::Canvas* canvas,
                                  const gfx::ImageSkia& frame_image,
                                  const gfx::ImageSkia& frame_overlay_image,
-                                 const SkPaint& paint,
+                                 const cc::PaintFlags& flags,
                                  const gfx::Rect& bounds,
                                  int corner_radius,
                                  int image_inset_x) {
   SkPath frame_path = MakeRoundRectPath(bounds, corner_radius, corner_radius);
-  // If |paint| is using an unusual SkBlendMode (this is the case while
+  // If |flags| is using an unusual SkBlendMode (this is the case while
   // crossfading), we must create a new canvas to overlay |frame_image| and
   // |frame_overlay_image| using |kSrcOver| and then paint the result
   // using the unusual mode. We try to avoid this because creating a new
   // browser-width canvas is expensive.
-  bool fast_path = (frame_overlay_image.isNull() || paint.isSrcOver());
+  bool fast_path = (frame_overlay_image.isNull() || flags.isSrcOver());
   if (fast_path) {
     if (frame_image.isNull()) {
-      canvas->DrawPath(frame_path, paint);
+      canvas->DrawPath(frame_path, flags);
     } else {
       canvas->DrawImageInPath(frame_image, -image_inset_x, 0, frame_path,
-                              paint);
+                              flags);
     }
 
     if (!frame_overlay_image.isNull()) {
       // Adjust |bounds| such that |frame_overlay_image| is not tiled.
       gfx::Rect overlay_bounds = bounds;
       overlay_bounds.Intersect(
           gfx::Rect(bounds.origin(), frame_overlay_image.size()));
       int top_left_corner_radius = corner_radius;
       int top_right_corner_radius = corner_radius;
       if (overlay_bounds.width() < bounds.width() - corner_radius)
         top_right_corner_radius = 0;
       canvas->DrawImageInPath(
           frame_overlay_image, 0, 0,
           MakeRoundRectPath(overlay_bounds, top_left_corner_radius,
                             top_right_corner_radius),
-          paint);
+          flags);
     }
   } else {
     gfx::Canvas temporary_canvas(bounds.size(), canvas->image_scale(), false);
     if (frame_image.isNull()) {
-      temporary_canvas.DrawColor(paint.getColor());
+      temporary_canvas.DrawColor(flags.getColor());
     } else {
       temporary_canvas.TileImageInt(frame_image, image_inset_x, 0, 0, 0,
                                     bounds.width(), bounds.height());
     }
     temporary_canvas.DrawImageInt(frame_overlay_image, 0, 0);
     canvas->DrawImageInPath(gfx::ImageSkia(temporary_canvas.ExtractImageRep()),
-                            0, 0, frame_path, paint);
+                            0, 0, frame_path, flags);
   }
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserHeaderPainterAsh, public:
 
 BrowserHeaderPainterAsh::BrowserHeaderPainterAsh()
     : frame_(nullptr),
@@ skipping 135 matching lines @@
   if (!active)
     alpha = 0xFF - alpha;
 
   if (alpha == 0)
     return;
 
   bool round_corners = !frame_->IsMaximized() && !frame_->IsFullscreen();
   gfx::ImageSkia frame_image = view_->GetFrameImage(active);
   gfx::ImageSkia frame_overlay_image = view_->GetFrameOverlayImage(active);
 
-  SkPaint paint;
-  paint.setBlendMode(SkBlendMode::kPlus);
-  paint.setAlpha(alpha);
-  paint.setColor(SkColorSetA(view_->GetFrameColor(active), alpha));
-  paint.setAntiAlias(round_corners);
+  cc::PaintFlags flags;
+  flags.setBlendMode(SkBlendMode::kPlus);
+  flags.setAlpha(alpha);
+  flags.setColor(SkColorSetA(view_->GetFrameColor(active), alpha));
+  flags.setAntiAlias(round_corners);
   PaintFrameImagesInRoundRect(
-      canvas, frame_image, frame_overlay_image, paint, GetPaintedBounds(),
+      canvas, frame_image, frame_overlay_image, flags, GetPaintedBounds(),
       round_corners ? ash::HeaderPainterUtil::GetTopCornerRadiusWhenRestored()
                     : 0,
       ash::HeaderPainterUtil::GetThemeBackgroundXInset());
 }
 
 void BrowserHeaderPainterAsh::PaintTitleBar(gfx::Canvas* canvas) {
   // The window icon is painted by its own views::View.
   gfx::Rect title_bounds = GetTitleBounds();
   title_bounds.set_x(view_->GetMirroredXForRect(title_bounds));
   canvas->DrawStringRectWithFlags(frame_->widget_delegate()->GetWindowTitle(),
@@ skipping 30 matching lines @@
 }
 
 gfx::Rect BrowserHeaderPainterAsh::GetPaintedBounds() const {
   return gfx::Rect(view_->width(), painted_height_);
 }
 
 gfx::Rect BrowserHeaderPainterAsh::GetTitleBounds() const {
   return ash::HeaderPainterUtil::GetTitleBounds(window_icon_,
       caption_button_container_, BrowserFrame::GetTitleFontList());
 }