ui: Fix cc/paint skia type mismatches

ui/native_theme/native_theme_win.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/native_theme/native_theme_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <uxtheme.h>
 #include <vsstyle.h>
@@ skipping 42 matching lines @@
   COLOR_GRAYTEXT,
   COLOR_HIGHLIGHT,
   COLOR_HIGHLIGHTTEXT,
   COLOR_HOTLIGHT,
   COLOR_MENUHIGHLIGHT,
   COLOR_SCROLLBAR,
   COLOR_WINDOW,
   COLOR_WINDOWTEXT,
 };
 
-void SetCheckerboardShader(cc::PaintFlags* flags, const RECT& align_rect) {
+void SetCheckerboardShader(SkPaint* paint, const RECT& align_rect) {
   // Create a 2x2 checkerboard pattern using the 3D face and highlight colors.
   const SkColor face = color_utils::GetSysSkColor(COLOR_3DFACE);
   const SkColor highlight = color_utils::GetSysSkColor(COLOR_3DHILIGHT);
   SkColor buffer[] = { face, highlight, highlight, face };
   // Confusing bit: we first create a temporary bitmap with our desired pattern,
   // then copy it to another bitmap.  The temporary bitmap doesn't take
   // ownership of the pixel data, and so will point to garbage when this
   // function returns.  The copy will copy the pixel data into a place owned by
   // the bitmap, which is in turn owned by the shader, etc., so it will live
   // until we're done using it.
   SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
   SkBitmap temp_bitmap;
   temp_bitmap.installPixels(info, buffer, info.minRowBytes());
   SkBitmap bitmap;
   temp_bitmap.copyTo(&bitmap);
 
   // Align the pattern with the upper corner of |align_rect|.
   SkMatrix local_matrix;
   local_matrix.setTranslate(SkIntToScalar(align_rect.left),
                             SkIntToScalar(align_rect.top));
-  flags->setShader(
+  paint->setShader(
       SkShader::MakeBitmapShader(bitmap, SkShader::kRepeat_TileMode,
                                  SkShader::kRepeat_TileMode, &local_matrix));
 }
 
 //    <-a->
 // [  *****             ]
 //  ____ |              |
 //  <-a-> <------b----->
 // a: object_width
 // b: frame_width
@@ skipping 263 matching lines @@
   UpdateSystemColors();
   is_using_high_contrast_valid_ = false;
   NotifyObservers();
 }
 
 void NativeThemeWin::UpdateSystemColors() {
   for (int kSystemColor : kSystemColors)
     system_colors_[kSystemColor] = color_utils::GetSysSkColor(kSystemColor);
 }
 
-void NativeThemeWin::PaintMenuSeparator(SkCanvas* canvas,
+void NativeThemeWin::PaintMenuSeparator(cc::PaintCanvas* canvas,
                                         const gfx::Rect& rect) const {
   cc::PaintFlags flags;
   flags.setColor(GetSystemColor(NativeTheme::kColorId_MenuSeparatorColor));
   int position_y = rect.y() + rect.height() / 2;
   canvas->drawLine(rect.x(), position_y, rect.right(), position_y, flags);
 }
 
-void NativeThemeWin::PaintMenuGutter(SkCanvas* canvas,
+void NativeThemeWin::PaintMenuGutter(cc::PaintCanvas* canvas,
                                      const gfx::Rect& rect) const {
   cc::PaintFlags flags;
   flags.setColor(GetSystemColor(NativeTheme::kColorId_MenuSeparatorColor));
   int position_x = rect.x() + rect.width() / 2;
   canvas->drawLine(position_x, rect.y(), position_x, rect.bottom(), flags);
 }
 
-void NativeThemeWin::PaintMenuBackground(SkCanvas* canvas,
+void NativeThemeWin::PaintMenuBackground(cc::PaintCanvas* canvas,
                                          const gfx::Rect& rect) const {
   cc::PaintFlags flags;
   flags.setColor(GetSystemColor(NativeTheme::kColorId_MenuBackgroundColor));
   canvas->drawRect(gfx::RectToSkRect(rect), flags);
 }
 
 void NativeThemeWin::PaintDirect(SkCanvas* destination_canvas,
                                  HDC hdc,
                                  Part part,
                                  State state,
@@ skipping 258 matching lines @@
       case NativeTheme::kColorId_ProminentButtonColor:
         return kProminentButtonColorInvert;
       default:
         return color_utils::InvertColor(GetAuraColor(color_id, this));
     }
   }
 
   return GetAuraColor(color_id, this);
 }
 
-void NativeThemeWin::PaintIndirect(SkCanvas* destination_canvas,
+void NativeThemeWin::PaintIndirect(cc::PaintCanvas* destination_canvas,
                                    Part part,
                                    State state,
                                    const gfx::Rect& rect,
                                    const ExtraParams& extra) const {
   // TODO(asvitkine): This path is pretty inefficient - for each paint operation
   // it creates a new offscreen bitmap Skia canvas. This can be sped up by doing
   // it only once per part/state and keeping a cache of the resulting bitmaps.
   //
   // TODO(enne): This could also potentially be sped up for software raster
   // by moving these draw ops into PaintRecord itself and then moving the
@@ skipping 630 matching lines @@
   }
 
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, part_id, state_id, &rect_win, NULL);
 
   // Draw it manually.
   if ((system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_3DFACE]) &&
       (system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_WINDOW])) {
     FillRect(hdc, &rect_win, reinterpret_cast<HBRUSH>(COLOR_SCROLLBAR + 1));
   } else {
-    cc::PaintFlags flags;
+    SkPaint paint;
     RECT align_rect = gfx::Rect(extra.track_x, extra.track_y, extra.track_width,
                                 extra.track_height).ToRECT();
-    SetCheckerboardShader(&flags, align_rect);
-    canvas->drawIRect(skia::RECTToSkIRect(rect_win), flags);
+    SetCheckerboardShader(&paint, align_rect);
+    canvas->drawIRect(skia::RECTToSkIRect(rect_win), paint);
   }
   if (extra.classic_state & DFCS_PUSHED)
     InvertRect(hdc, &rect_win);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintSpinButton(
     HDC hdc,
     Part part,
     State state,
@@ skipping 19 matching lines @@
       NOTREACHED();
       break;
   }
 
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, part_id, state_id, &rect_win, NULL);
   DrawFrameControl(hdc, &rect_win, DFC_SCROLL, extra.classic_state);
   return S_OK;
 }
 
-HRESULT NativeThemeWin::PaintTrackbar(
-    SkCanvas* canvas,
-    HDC hdc,
-    Part part,
-    State state,
-    const gfx::Rect& rect,
-    const TrackbarExtraParams& extra) const {
+HRESULT NativeThemeWin::PaintTrackbar(SkCanvas* canvas,
+                                      HDC hdc,
+                                      Part part,
+                                      State state,
+                                      const gfx::Rect& rect,
+                                      const TrackbarExtraParams& extra) const {
   const int part_id = extra.vertical ?
       ((part == kTrackbarTrack) ? TKP_TRACKVERT : TKP_THUMBVERT) :
       ((part == kTrackbarTrack) ? TKP_TRACK : TKP_THUMBBOTTOM);
 
   int state_id = TUS_NORMAL;
   switch (state) {
     case kDisabled:
       state_id = TUS_DISABLED;
       break;
     case kHovered:
@@ skipping 48 matching lines @@
     RECT right_half = bottom_section;
     right_half.left += ((bottom_section.right - bottom_section.left) / 2);
     left_half.right = right_half.left;
     DrawEdge(hdc, &left_half, EDGE_RAISED,
              BF_DIAGONAL_ENDTOPLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
     DrawEdge(hdc, &right_half, EDGE_RAISED,
              BF_DIAGONAL_ENDBOTTOMLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
 
     // If the button is pressed, draw hatching.
     if (extra.classic_state & DFCS_PUSHED) {
-      cc::PaintFlags flags;
-      SetCheckerboardShader(&flags, rect_win);
+      SkPaint paint;
+      SetCheckerboardShader(&paint, rect_win);
 
       // Fill all three pieces with the pattern.
-      canvas->drawIRect(skia::RECTToSkIRect(top_section), flags);
+      canvas->drawIRect(skia::RECTToSkIRect(top_section), paint);
 
       SkScalar left_triangle_top = SkIntToScalar(left_half.top);
       SkScalar left_triangle_right = SkIntToScalar(left_half.right);
       SkPath left_triangle;
       left_triangle.moveTo(SkIntToScalar(left_half.left), left_triangle_top);
       left_triangle.lineTo(left_triangle_right, left_triangle_top);
       left_triangle.lineTo(left_triangle_right,
                            SkIntToScalar(left_half.bottom));
       left_triangle.close();
-      canvas->drawPath(left_triangle, flags);
+      canvas->drawPath(left_triangle, paint);
 
       SkScalar right_triangle_left = SkIntToScalar(right_half.left);
       SkScalar right_triangle_top = SkIntToScalar(right_half.top);
       SkPath right_triangle;
       right_triangle.moveTo(right_triangle_left, right_triangle_top);
       right_triangle.lineTo(SkIntToScalar(right_half.right),
                             right_triangle_top);
       right_triangle.lineTo(right_triangle_left,
                             SkIntToScalar(right_half.bottom));
       right_triangle.close();
-      canvas->drawPath(right_triangle, flags);
+      canvas->drawPath(right_triangle, paint);
     }
   }
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintProgressBar(
     HDC hdc,
     const gfx::Rect& rect,
     const ProgressBarExtraParams& extra) const {
   // There is no documentation about the animation speed, frame-rate, nor
@@ skipping 624 matching lines @@
     break;
   case LAST:
     NOTREACHED();
     break;
   }
   theme_handles_[theme_name] = handle;
   return handle;
 }
 
 }  // namespace ui