ui/native_theme/native_theme_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/native_theme/native_theme_win.h"
   6
   7 #include <windows.h>
   8 #include <uxtheme.h>
   9 #include <vsstyle.h>
  10 #include <vssym32.h>
  11
  12 #include "base/basictypes.h"
  13 #include "base/logging.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/win/scoped_gdi_object.h"
  16 #include "base/win/scoped_hdc.h"
  17 #include "base/win/scoped_select_object.h"
  18 #include "base/win/windows_version.h"
  19 #include "skia/ext/bitmap_platform_device.h"
  20 #include "skia/ext/platform_canvas.h"
  21 #include "skia/ext/skia_utils_win.h"
  22 #include "third_party/skia/include/core/SkCanvas.h"
  23 #include "third_party/skia/include/core/SkColorPriv.h"
  24 #include "third_party/skia/include/core/SkShader.h"
  25 #include "ui/gfx/color_utils.h"
  26 #include "ui/gfx/gdi_util.h"
  27 #include "ui/gfx/rect.h"
  28 #include "ui/gfx/rect_conversions.h"
  29 #include "ui/gfx/win/dpi.h"
  30 #include "ui/native_theme/common_theme.h"
  31
  32 // This was removed from Winvers.h but is still used.
  33 #if !defined(COLOR_MENUHIGHLIGHT)
  34 #define COLOR_MENUHIGHLIGHT 29
  35 #endif
  36
  37 namespace {
  38
  39 // TODO: Obtain the correct colors using GetSysColor.
  40 // Theme colors returned by GetSystemColor().
  41 const SkColor kInvalidColorIdColor = SkColorSetRGB(255, 0, 128);
  42 // Dialogs:
  43 const SkColor kDialogBackgroundColor = SkColorSetRGB(251, 251, 251);
  44 // FocusableBorder:
  45 const SkColor kFocusedBorderColor = SkColorSetRGB(0x4d, 0x90, 0xfe);
  46 const SkColor kUnfocusedBorderColor = SkColorSetRGB(0xd9, 0xd9, 0xd9);
  47 // Button:
  48 const SkColor kButtonBackgroundColor = SkColorSetRGB(0xde, 0xde, 0xde);
  49 const SkColor kButtonHighlightColor = SkColorSetARGB(200, 255, 255, 255);
  50 const SkColor kButtonHoverColor = SkColorSetRGB(6, 45, 117);
  51 const SkColor kButtonHoverBackgroundColor = SkColorSetRGB(0xEA, 0xEA, 0xEA);
  52 // MenuItem:
  53 const SkColor kEnabledMenuItemForegroundColor = SkColorSetRGB(6, 45, 117);
  54 const SkColor kDisabledMenuItemForegroundColor = SkColorSetRGB(161, 161, 146);
  55 const SkColor kFocusedMenuItemBackgroundColor = SkColorSetRGB(246, 249, 253);
  56 const SkColor kMenuSeparatorColor = SkColorSetARGB(50, 0, 0, 0);
  57 // Table:
  58 const SkColor kTreeSelectionBackgroundUnfocused = SkColorSetRGB(240, 240, 240);
  59
  60 // Windows system color IDs cached and updated by the native theme.
  61 const int kSystemColors[] = {
  62   COLOR_3DFACE,
  63   COLOR_BTNTEXT,
  64   COLOR_GRAYTEXT,
  65   COLOR_HIGHLIGHT,
  66   COLOR_HIGHLIGHTTEXT,
  67   COLOR_SCROLLBAR,
  68   COLOR_WINDOW,
  69   COLOR_WINDOWTEXT,
  70   COLOR_BTNFACE,
  71   COLOR_MENUHIGHLIGHT,
  72 };
  73
  74 void SetCheckerboardShader(SkPaint* paint, const RECT& align_rect) {
  75   // Create a 2x2 checkerboard pattern using the 3D face and highlight colors.
  76   const SkColor face = color_utils::GetSysSkColor(COLOR_3DFACE);
  77   const SkColor highlight = color_utils::GetSysSkColor(COLOR_3DHILIGHT);
  78   SkColor buffer[] = { face, highlight, highlight, face };
  79   // Confusing bit: we first create a temporary bitmap with our desired pattern,
  80   // then copy it to another bitmap.  The temporary bitmap doesn't take
  81   // ownership of the pixel data, and so will point to garbage when this
  82   // function returns.  The copy will copy the pixel data into a place owned by
  83   // the bitmap, which is in turn owned by the shader, etc., so it will live
  84   // until we're done using it.
  85   SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
  86   SkBitmap temp_bitmap;
  87   temp_bitmap.installPixels(info, buffer, info.minRowBytes());
  88   SkBitmap bitmap;
  89   temp_bitmap.copyTo(&bitmap);
  90
  91   // Align the pattern with the upper corner of |align_rect|.
  92   SkMatrix local_matrix;
  93   local_matrix.setTranslate(SkIntToScalar(align_rect.left),
  94                             SkIntToScalar(align_rect.top));
  95   skia::RefPtr<SkShader> shader =
  96       skia::AdoptRef(SkShader::CreateBitmapShader(bitmap,
  97                                                   SkShader::kRepeat_TileMode,
  98                                                   SkShader::kRepeat_TileMode,
  99                                                   &local_matrix));
 100   paint->setShader(shader.get());
 101 }
 102
 103 //    <-a->
 104 // [  *****             ]
 105 //  ____ |              |
 106 //  <-a-> <------b----->
 107 // a: object_width
 108 // b: frame_width
 109 // *: animating object
 110 //
 111 // - the animation goes from "[" to "]" repeatedly.
 112 // - the animation offset is at first "|"
 113 //
 114 int ComputeAnimationProgress(int frame_width,
 115                              int object_width,
 116                              int pixels_per_second,
 117                              double animated_seconds) {
 118   int animation_width = frame_width + object_width;
 119   double interval = static_cast<double>(animation_width) / pixels_per_second;
 120   double ratio = fmod(animated_seconds, interval) / interval;
 121   return static_cast<int>(animation_width * ratio) - object_width;
 122 }
 123
 124 RECT InsetRect(const RECT* rect, int size) {
 125   gfx::Rect result(*rect);
 126   result.Inset(size, size);
 127   return result.ToRECT();
 128 }
 129
 130 }  // namespace
 131
 132 namespace ui {
 133
 134 bool NativeThemeWin::IsThemingActive() const {
 135   return is_theme_active_ && is_theme_active_();
 136 }
 137
 138 bool NativeThemeWin::IsUsingHighContrastTheme() const {
 139   if (is_using_high_contrast_valid_)
 140     return is_using_high_contrast_;
 141   HIGHCONTRAST result;
 142   result.cbSize = sizeof(HIGHCONTRAST);
 143   is_using_high_contrast_ =
 144       SystemParametersInfo(SPI_GETHIGHCONTRAST, result.cbSize, &result, 0) &&
 145       (result.dwFlags & HCF_HIGHCONTRASTON) == HCF_HIGHCONTRASTON;
 146   is_using_high_contrast_valid_ = true;
 147   return is_using_high_contrast_;
 148 }
 149
 150 HRESULT NativeThemeWin::GetThemeColor(ThemeName theme,
 151                                       int part_id,
 152                                       int state_id,
 153                                       int prop_id,
 154                                       SkColor* color) const {
 155   HANDLE handle = GetThemeHandle(theme);
 156   if (!handle || !get_theme_color_)
 157     return E_NOTIMPL;
 158   COLORREF color_ref;
 159   if (get_theme_color_(handle, part_id, state_id, prop_id, &color_ref) != S_OK)
 160     return E_NOTIMPL;
 161   *color = skia::COLORREFToSkColor(color_ref);
 162   return S_OK;
 163 }
 164
 165 SkColor NativeThemeWin::GetThemeColorWithDefault(ThemeName theme,
 166                                                  int part_id,
 167                                                  int state_id,
 168                                                  int prop_id,
 169                                                  int default_sys_color) const {
 170   SkColor color;
 171   return (GetThemeColor(theme, part_id, state_id, prop_id, &color) == S_OK) ?
 172       color : color_utils::GetSysSkColor(default_sys_color);
 173 }
 174
 175 gfx::Size NativeThemeWin::GetThemeBorderSize(ThemeName theme) const {
 176   // For simplicity use the wildcard state==0, part==0, since it works
 177   // for the cases we currently depend on.
 178   int border;
 179   return (GetThemeInt(theme, 0, 0, TMT_BORDERSIZE, &border) == S_OK) ?
 180       gfx::Size(border, border) :
 181       gfx::Size(GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
 182 }
 183
 184 void NativeThemeWin::DisableTheming() const {
 185   if (set_theme_properties_)
 186     set_theme_properties_(0);
 187 }
 188
 189 void NativeThemeWin::CloseHandles() const {
 190   if (!close_theme_)
 191     return;
 192
 193   for (int i = 0; i < LAST; ++i) {
 194     if (theme_handles_[i]) {
 195       close_theme_(theme_handles_[i]);
 196       theme_handles_[i] = NULL;
 197     }
 198   }
 199 }
 200
 201 bool NativeThemeWin::IsClassicTheme(ThemeName name) const {
 202   return !theme_dll_ || !GetThemeHandle(name);
 203 }
 204
 205 // static
 206 NativeThemeWin* NativeThemeWin::instance() {
 207   CR_DEFINE_STATIC_LOCAL(NativeThemeWin, s_native_theme, ());
 208   return &s_native_theme;
 209 }
 210
 211 gfx::Size NativeThemeWin::GetPartSize(Part part,
 212                                       State state,
 213                                       const ExtraParams& extra) const {
 214   gfx::Size part_size = CommonThemeGetPartSize(part, state, extra);
 215   if (!part_size.IsEmpty())
 216     return part_size;
 217
 218   // The GetThemePartSize call below returns the default size without
 219   // accounting for user customization (crbug/218291).
 220   switch (part) {
 221     case kScrollbarDownArrow:
 222     case kScrollbarLeftArrow:
 223     case kScrollbarRightArrow:
 224     case kScrollbarUpArrow:
 225     case kScrollbarHorizontalThumb:
 226     case kScrollbarVerticalThumb:
 227     case kScrollbarHorizontalTrack:
 228     case kScrollbarVerticalTrack: {
 229       int size = gfx::win::GetSystemMetricsInDIP(SM_CXVSCROLL);
 230       if (size == 0)
 231         size = 17;
 232       return gfx::Size(size, size);
 233     }
 234     default:
 235       break;
 236   }
 237
 238   int part_id = GetWindowsPart(part, state, extra);
 239   int state_id = GetWindowsState(part, state, extra);
 240
 241   base::win::ScopedGetDC screen_dc(NULL);
 242   SIZE size;
 243   if (SUCCEEDED(GetThemePartSize(GetThemeName(part), screen_dc, part_id,
 244                                  state_id, NULL, TS_TRUE, &size)))
 245     return gfx::Size(size.cx, size.cy);
 246
 247   // TODO(rogerta): For now, we need to support radio buttons and checkboxes
 248   // when theming is not enabled.  Support for other parts can be added
 249   // if/when needed.
 250   return (part == kCheckbox || part == kRadio) ?
 251       gfx::Size(13, 13) : gfx::Size();
 252 }
 253
 254 void NativeThemeWin::Paint(SkCanvas* canvas,
 255                            Part part,
 256                            State state,
 257                            const gfx::Rect& rect,
 258                            const ExtraParams& extra) const {
 259   if (rect.IsEmpty())
 260     return;
 261
 262   switch (part) {
 263     case kComboboxArrow:
 264       CommonThemePaintComboboxArrow(canvas, rect);
 265       return;
 266     case kMenuPopupGutter:
 267       CommonThemePaintMenuGutter(canvas, rect);
 268       return;
 269     case kMenuPopupSeparator:
 270       CommonThemePaintMenuSeparator(canvas, rect, extra.menu_separator);
 271       return;
 272     case kMenuPopupBackground:
 273       CommonThemePaintMenuBackground(canvas, rect);
 274       return;
 275     case kMenuItemBackground:
 276       CommonThemePaintMenuItemBackground(canvas, state, rect);
 277       return;
 278     default:
 279       break;
 280   }
 281
 282   bool needs_paint_indirect = false;
 283   if (!skia::SupportsPlatformPaint(canvas)) {
 284     // This block will only get hit with --enable-accelerated-drawing flag.
 285     needs_paint_indirect = true;
 286   } else {
 287     // Scrollbar components on Windows Classic theme (on all Windows versions)
 288     // have particularly problematic alpha values, so always draw them
 289     // indirectly. In addition, scrollbar thumbs and grippers for the Windows XP
 290     // theme (available only on Windows XP) also need their alpha values
 291     // fixed.
 292     switch (part) {
 293       case kScrollbarDownArrow:
 294       case kScrollbarUpArrow:
 295       case kScrollbarLeftArrow:
 296       case kScrollbarRightArrow:
 297         needs_paint_indirect = !GetThemeHandle(SCROLLBAR);
 298         break;
 299       case kScrollbarHorizontalThumb:
 300       case kScrollbarVerticalThumb:
 301       case kScrollbarHorizontalGripper:
 302       case kScrollbarVerticalGripper:
 303         needs_paint_indirect = !GetThemeHandle(SCROLLBAR) ||
 304             base::win::GetVersion() == base::win::VERSION_XP;
 305         break;
 306       default:
 307         break;
 308     }
 309   }
 310
 311   if (needs_paint_indirect)
 312     PaintIndirect(canvas, part, state, rect, extra);
 313   else
 314     PaintDirect(canvas, part, state, rect, extra);
 315 }
 316
 317 NativeThemeWin::NativeThemeWin()
 318     : theme_dll_(LoadLibrary(L"uxtheme.dll")),
 319       draw_theme_(NULL),
 320       draw_theme_ex_(NULL),
 321       get_theme_color_(NULL),
 322       get_theme_content_rect_(NULL),
 323       get_theme_part_size_(NULL),
 324       open_theme_(NULL),
 325       close_theme_(NULL),
 326       set_theme_properties_(NULL),
 327       is_theme_active_(NULL),
 328       get_theme_int_(NULL),
 329       color_change_listener_(this),
 330       is_using_high_contrast_(false),
 331       is_using_high_contrast_valid_(false) {
 332   if (theme_dll_) {
 333     draw_theme_ = reinterpret_cast<DrawThemeBackgroundPtr>(
 334         GetProcAddress(theme_dll_, "DrawThemeBackground"));
 335     draw_theme_ex_ = reinterpret_cast<DrawThemeBackgroundExPtr>(
 336         GetProcAddress(theme_dll_, "DrawThemeBackgroundEx"));
 337     get_theme_color_ = reinterpret_cast<GetThemeColorPtr>(
 338         GetProcAddress(theme_dll_, "GetThemeColor"));
 339     get_theme_content_rect_ = reinterpret_cast<GetThemeContentRectPtr>(
 340         GetProcAddress(theme_dll_, "GetThemeBackgroundContentRect"));
 341     get_theme_part_size_ = reinterpret_cast<GetThemePartSizePtr>(
 342         GetProcAddress(theme_dll_, "GetThemePartSize"));
 343     open_theme_ = reinterpret_cast<OpenThemeDataPtr>(
 344         GetProcAddress(theme_dll_, "OpenThemeData"));
 345     close_theme_ = reinterpret_cast<CloseThemeDataPtr>(
 346         GetProcAddress(theme_dll_, "CloseThemeData"));
 347     set_theme_properties_ = reinterpret_cast<SetThemeAppPropertiesPtr>(
 348         GetProcAddress(theme_dll_, "SetThemeAppProperties"));
 349     is_theme_active_ = reinterpret_cast<IsThemeActivePtr>(
 350         GetProcAddress(theme_dll_, "IsThemeActive"));
 351     get_theme_int_ = reinterpret_cast<GetThemeIntPtr>(
 352         GetProcAddress(theme_dll_, "GetThemeInt"));
 353   }
 354   memset(theme_handles_, 0, sizeof(theme_handles_));
 355
 356   // Initialize the cached system colors.
 357   UpdateSystemColors();
 358 }
 359
 360 NativeThemeWin::~NativeThemeWin() {
 361   if (theme_dll_) {
 362     // todo (cpu): fix this soon.  Making a call to CloseHandles() here breaks
 363     // certain tests and the reliability bots.
 364     // CloseHandles();
 365     FreeLibrary(theme_dll_);
 366   }
 367 }
 368
 369 void NativeThemeWin::OnSysColorChange() {
 370   UpdateSystemColors();
 371   is_using_high_contrast_valid_ = false;
 372   NotifyObservers();
 373 }
 374
 375 void NativeThemeWin::UpdateSystemColors() {
 376   for (int i = 0; i < arraysize(kSystemColors); ++i) {
 377     system_colors_[kSystemColors[i]] =
 378         color_utils::GetSysSkColor(kSystemColors[i]);
 379   }
 380 }
 381
 382 void NativeThemeWin::PaintDirect(SkCanvas* canvas,
 383                                  Part part,
 384                                  State state,
 385                                  const gfx::Rect& rect,
 386                                  const ExtraParams& extra) const {
 387   skia::ScopedPlatformPaint scoped_platform_paint(canvas);
 388   HDC hdc = scoped_platform_paint.GetPlatformSurface();
 389
 390   switch (part) {
 391     case kCheckbox:
 392       PaintCheckbox(hdc, part, state, rect, extra.button);
 393       return;
 394     case kInnerSpinButton:
 395       PaintSpinButton(hdc, part, state, rect, extra.inner_spin);
 396       return;
 397     case kMenuList:
 398       PaintMenuList(hdc, state, rect, extra.menu_list);
 399       return;
 400     case kMenuCheck:
 401       PaintMenuCheck(hdc, state, rect, extra.menu_check);
 402       return;
 403     case kMenuCheckBackground:
 404       PaintMenuCheckBackground(hdc, state, rect);
 405       return;
 406     case kMenuPopupArrow:
 407       PaintMenuArrow(hdc, state, rect, extra.menu_arrow);
 408       return;
 409     case kMenuPopupBackground:
 410       PaintMenuBackground(hdc, rect);
 411       return;
 412     case kMenuPopupGutter:
 413       PaintMenuGutter(hdc, rect);
 414       return;
 415     case kMenuPopupSeparator:
 416       PaintMenuSeparator(hdc, rect, extra.menu_separator);
 417       return;
 418     case kMenuItemBackground:
 419       PaintMenuItemBackground(hdc, state, rect, extra.menu_item);
 420       return;
 421     case kProgressBar:
 422       PaintProgressBar(hdc, rect, extra.progress_bar);
 423       return;
 424     case kPushButton:
 425       PaintPushButton(hdc, part, state, rect, extra.button);
 426       return;
 427     case kRadio:
 428       PaintRadioButton(hdc, part, state, rect, extra.button);
 429       return;
 430     case kScrollbarDownArrow:
 431     case kScrollbarUpArrow:
 432     case kScrollbarLeftArrow:
 433     case kScrollbarRightArrow:
 434       PaintScrollbarArrow(hdc, part, state, rect, extra.scrollbar_arrow);
 435       return;
 436     case kScrollbarHorizontalThumb:
 437     case kScrollbarVerticalThumb:
 438     case kScrollbarHorizontalGripper:
 439     case kScrollbarVerticalGripper:
 440       PaintScrollbarThumb(hdc, part, state, rect, extra.scrollbar_thumb);
 441       return;
 442     case kScrollbarHorizontalTrack:
 443     case kScrollbarVerticalTrack:
 444       PaintScrollbarTrack(canvas, hdc, part, state, rect,
 445                           extra.scrollbar_track);
 446       return;
 447     case kScrollbarCorner:
 448       canvas->drawColor(SK_ColorWHITE, SkXfermode::kSrc_Mode);
 449       return;
 450     case kTabPanelBackground:
 451       PaintTabPanelBackground(hdc, rect);
 452       return;
 453     case kTextField:
 454       PaintTextField(hdc, part, state, rect, extra.text_field);
 455       return;
 456     case kTrackbarThumb:
 457     case kTrackbarTrack:
 458       PaintTrackbar(canvas, hdc, part, state, rect, extra.trackbar);
 459       return;
 460     case kWindowResizeGripper:
 461       PaintWindowResizeGripper(hdc, rect);
 462       return;
 463     case kComboboxArrow:
 464     case kSliderTrack:
 465     case kSliderThumb:
 466     case kMaxPart:
 467       NOTREACHED();
 468   }
 469 }
 470
 471 SkColor NativeThemeWin::GetSystemColor(ColorId color_id) const {
 472   SkColor color;
 473   if (CommonThemeGetSystemColor(color_id, &color))
 474     return color;
 475
 476   switch (color_id) {
 477     // Windows
 478     case kColorId_WindowBackground:
 479       return system_colors_[COLOR_WINDOW];
 480
 481     // Dialogs
 482     case kColorId_DialogBackground:
 483       return gfx::IsInvertedColorScheme() ?
 484           color_utils::InvertColor(kDialogBackgroundColor) :
 485           kDialogBackgroundColor;
 486
 487     // FocusableBorder
 488     case kColorId_FocusedBorderColor:
 489       return kFocusedBorderColor;
 490     case kColorId_UnfocusedBorderColor:
 491       return kUnfocusedBorderColor;
 492
 493     // Button
 494     case kColorId_ButtonBackgroundColor:
 495       return kButtonBackgroundColor;
 496     case kColorId_ButtonEnabledColor:
 497       return system_colors_[COLOR_BTNTEXT];
 498     case kColorId_ButtonDisabledColor:
 499       return system_colors_[COLOR_GRAYTEXT];
 500     case kColorId_ButtonHighlightColor:
 501       return kButtonHighlightColor;
 502     case kColorId_ButtonHoverColor:
 503       return kButtonHoverColor;
 504     case kColorId_ButtonHoverBackgroundColor:
 505       return kButtonHoverBackgroundColor;
 506     case kColorId_BlueButtonEnabledColor:
 507     case kColorId_BlueButtonDisabledColor:
 508     case kColorId_BlueButtonPressedColor:
 509     case kColorId_BlueButtonHoverColor:
 510       NOTREACHED();
 511       return kInvalidColorIdColor;
 512
 513     // MenuItem
 514     case kColorId_EnabledMenuItemForegroundColor:
 515       return kEnabledMenuItemForegroundColor;
 516     case kColorId_DisabledMenuItemForegroundColor:
 517       return kDisabledMenuItemForegroundColor;
 518     case kColorId_DisabledEmphasizedMenuItemForegroundColor:
 519       return SK_ColorBLACK;
 520     case kColorId_FocusedMenuItemBackgroundColor:
 521       return kFocusedMenuItemBackgroundColor;
 522     case kColorId_MenuSeparatorColor:
 523       return kMenuSeparatorColor;
 524     case kColorId_SelectedMenuItemForegroundColor:
 525     case kColorId_HoverMenuItemBackgroundColor:
 526     case kColorId_MenuBackgroundColor:
 527     case kColorId_MenuBorderColor:
 528       NOTREACHED();
 529       return kInvalidColorIdColor;
 530
 531     // MenuButton
 532     case kColorId_EnabledMenuButtonBorderColor:
 533     case kColorId_FocusedMenuButtonBorderColor:
 534     case kColorId_HoverMenuButtonBorderColor:
 535       NOTREACHED();
 536       return kInvalidColorIdColor;
 537
 538     // Label
 539     case kColorId_LabelEnabledColor:
 540       return system_colors_[COLOR_BTNTEXT];
 541     case kColorId_LabelDisabledColor:
 542       return system_colors_[COLOR_GRAYTEXT];
 543     case kColorId_LabelBackgroundColor:
 544       return system_colors_[COLOR_WINDOW];
 545
 546     // Textfield
 547     case kColorId_TextfieldDefaultColor:
 548       return system_colors_[COLOR_WINDOWTEXT];
 549     case kColorId_TextfieldDefaultBackground:
 550       return system_colors_[COLOR_WINDOW];
 551     case kColorId_TextfieldReadOnlyColor:
 552       return system_colors_[COLOR_GRAYTEXT];
 553     case kColorId_TextfieldReadOnlyBackground:
 554       return system_colors_[COLOR_3DFACE];
 555     case kColorId_TextfieldSelectionColor:
 556       return system_colors_[COLOR_HIGHLIGHTTEXT];
 557     case kColorId_TextfieldSelectionBackgroundFocused:
 558       return system_colors_[COLOR_HIGHLIGHT];
 559
 560     // Tooltip
 561     case kColorId_TooltipBackground:
 562     case kColorId_TooltipText:
 563       NOTREACHED();
 564       return kInvalidColorIdColor;
 565
 566     // Tree
 567     // NOTE: these aren't right for all themes, but as close as I could get.
 568     case kColorId_TreeBackground:
 569       return system_colors_[COLOR_WINDOW];
 570     case kColorId_TreeText:
 571       return system_colors_[COLOR_WINDOWTEXT];
 572     case kColorId_TreeSelectedText:
 573       return system_colors_[COLOR_HIGHLIGHTTEXT];
 574     case kColorId_TreeSelectedTextUnfocused:
 575       return system_colors_[COLOR_BTNTEXT];
 576     case kColorId_TreeSelectionBackgroundFocused:
 577       return system_colors_[COLOR_HIGHLIGHT];
 578     case kColorId_TreeSelectionBackgroundUnfocused:
 579       return system_colors_[IsUsingHighContrastTheme() ?
 580                               COLOR_MENUHIGHLIGHT : COLOR_BTNFACE];
 581     case kColorId_TreeArrow:
 582       return system_colors_[COLOR_WINDOWTEXT];
 583
 584     // Table
 585     case kColorId_TableBackground:
 586       return system_colors_[COLOR_WINDOW];
 587     case kColorId_TableText:
 588       return system_colors_[COLOR_WINDOWTEXT];
 589     case kColorId_TableSelectedText:
 590       return system_colors_[COLOR_HIGHLIGHTTEXT];
 591     case kColorId_TableSelectedTextUnfocused:
 592       return system_colors_[COLOR_BTNTEXT];
 593     case kColorId_TableSelectionBackgroundFocused:
 594       return system_colors_[COLOR_HIGHLIGHT];
 595     case kColorId_TableSelectionBackgroundUnfocused:
 596       return system_colors_[IsUsingHighContrastTheme() ?
 597                               COLOR_MENUHIGHLIGHT : COLOR_BTNFACE];
 598     case kColorId_TableGroupingIndicatorColor:
 599       return system_colors_[COLOR_GRAYTEXT];
 600
 601     // Results Tables
 602     case kColorId_ResultsTableNormalBackground:
 603       return system_colors_[COLOR_WINDOW];
 604     case kColorId_ResultsTableHoveredBackground:
 605       return color_utils::AlphaBlend(system_colors_[COLOR_HIGHLIGHT],
 606                                      system_colors_[COLOR_WINDOW], 0x40);
 607     case kColorId_ResultsTableSelectedBackground:
 608       return system_colors_[COLOR_HIGHLIGHT];
 609     case kColorId_ResultsTableNormalText:
 610     case kColorId_ResultsTableHoveredText:
 611       return system_colors_[COLOR_WINDOWTEXT];
 612     case kColorId_ResultsTableSelectedText:
 613       return system_colors_[COLOR_HIGHLIGHTTEXT];
 614     case kColorId_ResultsTableNormalDimmedText:
 615       return color_utils::AlphaBlend(system_colors_[COLOR_WINDOWTEXT],
 616                                      system_colors_[COLOR_WINDOW], 0x80);
 617     case kColorId_ResultsTableHoveredDimmedText:
 618       return color_utils::AlphaBlend(
 619           system_colors_[COLOR_WINDOWTEXT],
 620           GetSystemColor(kColorId_ResultsTableHoveredBackground), 0x80);
 621     case kColorId_ResultsTableSelectedDimmedText:
 622       return color_utils::AlphaBlend(system_colors_[COLOR_HIGHLIGHTTEXT],
 623                                      system_colors_[COLOR_HIGHLIGHT], 0x80);
 624     case kColorId_ResultsTableNormalUrl:
 625       return color_utils::GetReadableColor(SkColorSetRGB(0, 128, 0),
 626                                            system_colors_[COLOR_WINDOW]);
 627     case kColorId_ResultsTableHoveredUrl:
 628       return color_utils::GetReadableColor(
 629           SkColorSetRGB(0, 128, 0),
 630           GetSystemColor(kColorId_ResultsTableHoveredBackground));
 631     case kColorId_ResultsTableSelectedUrl:
 632       return color_utils::GetReadableColor(SkColorSetRGB(0, 128, 0),
 633                                            system_colors_[COLOR_HIGHLIGHT]);
 634     case kColorId_ResultsTableNormalDivider:
 635       return color_utils::AlphaBlend(system_colors_[COLOR_WINDOWTEXT],
 636                                      system_colors_[COLOR_WINDOW], 0x34);
 637     case kColorId_ResultsTableHoveredDivider:
 638       return color_utils::AlphaBlend(
 639           system_colors_[COLOR_WINDOWTEXT],
 640           GetSystemColor(kColorId_ResultsTableHoveredBackground), 0x34);
 641     case kColorId_ResultsTableSelectedDivider:
 642       return color_utils::AlphaBlend(system_colors_[COLOR_HIGHLIGHTTEXT],
 643                                      system_colors_[COLOR_HIGHLIGHT], 0x34);
 644   }
 645   NOTREACHED();
 646   return kInvalidColorIdColor;
 647 }
 648
 649 void NativeThemeWin::PaintIndirect(SkCanvas* canvas,
 650                                    Part part,
 651                                    State state,
 652                                    const gfx::Rect& rect,
 653                                    const ExtraParams& extra) const {
 654   // TODO(asvitkine): This path is pretty inefficient - for each paint operation
 655   //                  it creates a new offscreen bitmap Skia canvas. This can
 656   //                  be sped up by doing it only once per part/state and
 657   //                  keeping a cache of the resulting bitmaps.
 658
 659   // Create an offscreen canvas that is backed by an HDC.
 660   skia::RefPtr<skia::BitmapPlatformDevice> device = skia::AdoptRef(
 661       skia::BitmapPlatformDevice::Create(
 662           rect.width(), rect.height(), false, NULL));
 663   DCHECK(device);
 664   SkCanvas offscreen_canvas(device.get());
 665   DCHECK(skia::SupportsPlatformPaint(&offscreen_canvas));
 666
 667   // Some of the Windows theme drawing operations do not write correct alpha
 668   // values for fully-opaque pixels; instead the pixels get alpha 0. This is
 669   // especially a problem on Windows XP or when using the Classic theme.
 670   //
 671   // To work-around this, mark all pixels with a placeholder value, to detect
 672   // which pixels get touched by the paint operation. After paint, set any
 673   // pixels that have alpha 0 to opaque and placeholders to fully-transparent.
 674   const SkColor placeholder = SkColorSetARGB(1, 0, 0, 0);
 675   offscreen_canvas.clear(placeholder);
 676
 677   // Offset destination rects to have origin (0,0).
 678   gfx::Rect adjusted_rect(rect.size());
 679   ExtraParams adjusted_extra(extra);
 680   switch (part) {
 681     case kProgressBar:
 682       adjusted_extra.progress_bar.value_rect_x = 0;
 683       adjusted_extra.progress_bar.value_rect_y = 0;
 684       break;
 685     case kScrollbarHorizontalTrack:
 686     case kScrollbarVerticalTrack:
 687       adjusted_extra.scrollbar_track.track_x = 0;
 688       adjusted_extra.scrollbar_track.track_y = 0;
 689       break;
 690     default:
 691       break;
 692   }
 693   // Draw the theme controls using existing HDC-drawing code.
 694   PaintDirect(&offscreen_canvas, part, state, adjusted_rect, adjusted_extra);
 695
 696   // Copy the pixels to a bitmap that has ref-counted pixel storage, which is
 697   // necessary to have when drawing to a SkPicture.
 698   const SkBitmap& hdc_bitmap =
 699       offscreen_canvas.getDevice()->accessBitmap(false);
 700   SkBitmap bitmap;
 701   hdc_bitmap.copyTo(&bitmap, kN32_SkColorType);
 702
 703   // Post-process the pixels to fix up the alpha values (see big comment above).
 704   const SkPMColor placeholder_value = SkPreMultiplyColor(placeholder);
 705   const int pixel_count = rect.width() * rect.height();
 706   SkPMColor* pixels = bitmap.getAddr32(0, 0);
 707   for (int i = 0; i < pixel_count; i++) {
 708     if (pixels[i] == placeholder_value) {
 709       // Pixel wasn't touched - make it fully transparent.
 710       pixels[i] = SkPackARGB32(0, 0, 0, 0);
 711     } else if (SkGetPackedA32(pixels[i]) == 0) {
 712       // Pixel was touched but has incorrect alpha of 0, make it fully opaque.
 713       pixels[i] = SkPackARGB32(0xFF,
 714                                SkGetPackedR32(pixels[i]),
 715                                SkGetPackedG32(pixels[i]),
 716                                SkGetPackedB32(pixels[i]));
 717     }
 718   }
 719
 720   // Draw the offscreen bitmap to the destination canvas.
 721   canvas->drawBitmap(bitmap, rect.x(), rect.y());
 722 }
 723
 724 HRESULT NativeThemeWin::GetThemePartSize(ThemeName theme_name,
 725                                          HDC hdc,
 726                                          int part_id,
 727                                          int state_id,
 728                                          RECT* rect,
 729                                          int ts,
 730                                          SIZE* size) const {
 731   HANDLE handle = GetThemeHandle(theme_name);
 732   return (handle && get_theme_part_size_) ?
 733       get_theme_part_size_(handle, hdc, part_id, state_id, rect, ts, size) :
 734       E_NOTIMPL;
 735 }
 736
 737 HRESULT NativeThemeWin::PaintButton(HDC hdc,
 738                                     State state,
 739                                     const ButtonExtraParams& extra,
 740                                     int part_id,
 741                                     int state_id,
 742                                     RECT* rect) const {
 743   HANDLE handle = GetThemeHandle(BUTTON);
 744   if (handle && draw_theme_)
 745     return draw_theme_(handle, hdc, part_id, state_id, rect, NULL);
 746
 747   // Adjust classic_state based on part, state, and extras.
 748   int classic_state = extra.classic_state;
 749   switch (part_id) {
 750     case BP_CHECKBOX:
 751       classic_state |= DFCS_BUTTONCHECK;
 752       break;
 753     case BP_RADIOBUTTON:
 754       classic_state |= DFCS_BUTTONRADIO;
 755       break;
 756     case BP_PUSHBUTTON:
 757       classic_state |= DFCS_BUTTONPUSH;
 758       break;
 759     default:
 760       NOTREACHED();
 761       break;
 762   }
 763
 764   switch (state) {
 765     case kDisabled:
 766       classic_state |= DFCS_INACTIVE;
 767       break;
 768     case kHovered:
 769     case kNormal:
 770       break;
 771     case kPressed:
 772       classic_state |= DFCS_PUSHED;
 773       break;
 774     case kNumStates:
 775       NOTREACHED();
 776       break;
 777   }
 778
 779   if (extra.checked)
 780     classic_state |= DFCS_CHECKED;
 781
 782   // Draw it manually.
 783   // All pressed states have both low bits set, and no other states do.
 784   const bool focused = ((state_id & ETS_FOCUSED) == ETS_FOCUSED);
 785   const bool pressed = ((state_id & PBS_PRESSED) == PBS_PRESSED);
 786   if ((BP_PUSHBUTTON == part_id) && (pressed || focused)) {
 787     // BP_PUSHBUTTON has a focus rect drawn around the outer edge, and the
 788     // button itself is shrunk by 1 pixel.
 789     HBRUSH brush = GetSysColorBrush(COLOR_3DDKSHADOW);
 790     if (brush) {
 791       FrameRect(hdc, rect, brush);
 792       InflateRect(rect, -1, -1);
 793     }
 794   }
 795   DrawFrameControl(hdc, rect, DFC_BUTTON, classic_state);
 796
 797   // Draw the focus rectangle (the dotted line box) only on buttons.  For radio
 798   // and checkboxes, we let webkit draw the focus rectangle (orange glow).
 799   if ((BP_PUSHBUTTON == part_id) && focused) {
 800     // The focus rect is inside the button.  The exact number of pixels depends
 801     // on whether we're in classic mode or using uxtheme.
 802     if (handle && get_theme_content_rect_) {
 803       get_theme_content_rect_(handle, hdc, part_id, state_id, rect, rect);
 804     } else {
 805       InflateRect(rect, -GetSystemMetrics(SM_CXEDGE),
 806                   -GetSystemMetrics(SM_CYEDGE));
 807     }
 808     DrawFocusRect(hdc, rect);
 809   }
 810
 811   // Classic theme doesn't support indeterminate checkboxes.  We draw
 812   // a recangle inside a checkbox like IE10 does.
 813   if (part_id == BP_CHECKBOX && extra.indeterminate) {
 814     RECT inner_rect = *rect;
 815     // "4 / 13" is same as IE10 in classic theme.
 816     int padding = (inner_rect.right - inner_rect.left) * 4 / 13;
 817     InflateRect(&inner_rect, -padding, -padding);
 818     int color_index = state == kDisabled ? COLOR_GRAYTEXT : COLOR_WINDOWTEXT;
 819     FillRect(hdc, &inner_rect, GetSysColorBrush(color_index));
 820   }
 821
 822   return S_OK;
 823 }
 824
 825 HRESULT NativeThemeWin::PaintMenuSeparator(
 826     HDC hdc,
 827     const gfx::Rect& rect,
 828     const MenuSeparatorExtraParams& extra) const {
 829   RECT rect_win = rect.ToRECT();
 830
 831   HANDLE handle = GetThemeHandle(MENU);
 832   if (handle && draw_theme_) {
 833     // Delta is needed for non-classic to move separator up slightly.
 834     --rect_win.top;
 835     --rect_win.bottom;
 836     return draw_theme_(handle, hdc, MENU_POPUPSEPARATOR, MPI_NORMAL, &rect_win,
 837                        NULL);
 838   }
 839
 840   DrawEdge(hdc, &rect_win, EDGE_ETCHED, BF_TOP);
 841   return S_OK;
 842 }
 843
 844 HRESULT NativeThemeWin::PaintMenuGutter(HDC hdc,
 845                                         const gfx::Rect& rect) const {
 846   RECT rect_win = rect.ToRECT();
 847   HANDLE handle = GetThemeHandle(MENU);
 848   return (handle && draw_theme_) ?
 849       draw_theme_(handle, hdc, MENU_POPUPGUTTER, MPI_NORMAL, &rect_win, NULL) :
 850       E_NOTIMPL;
 851 }
 852
 853 HRESULT NativeThemeWin::PaintMenuArrow(
 854     HDC hdc,
 855     State state,
 856     const gfx::Rect& rect,
 857     const MenuArrowExtraParams& extra) const {
 858   int state_id = MSM_NORMAL;
 859   if (state == kDisabled)
 860     state_id = MSM_DISABLED;
 861
 862   HANDLE handle = GetThemeHandle(MENU);
 863   RECT rect_win = rect.ToRECT();
 864   if (handle && draw_theme_) {
 865     if (extra.pointing_right) {
 866       return draw_theme_(handle, hdc, MENU_POPUPSUBMENU, state_id, &rect_win,
 867                          NULL);
 868     }
 869     // There is no way to tell the uxtheme API to draw a left pointing arrow; it
 870     // doesn't have a flag equivalent to DFCS_MENUARROWRIGHT.  But they are
 871     // needed for RTL locales on Vista.  So use a memory DC and mirror the
 872     // region with GDI's StretchBlt.
 873     gfx::Rect r(rect);
 874     base::win::ScopedCreateDC mem_dc(CreateCompatibleDC(hdc));
 875     base::win::ScopedBitmap mem_bitmap(CreateCompatibleBitmap(hdc, r.width(),
 876                                                               r.height()));
 877     base::win::ScopedSelectObject select_bitmap(mem_dc, mem_bitmap);
 878     // Copy and horizontally mirror the background from hdc into mem_dc. Use
 879     // a negative-width source rect, starting at the rightmost pixel.
 880     StretchBlt(mem_dc, 0, 0, r.width(), r.height(),
 881                 hdc, r.right()-1, r.y(), -r.width(), r.height(), SRCCOPY);
 882     // Draw the arrow.
 883     RECT theme_rect = {0, 0, r.width(), r.height()};
 884     HRESULT result = draw_theme_(handle, mem_dc, MENU_POPUPSUBMENU,
 885                                   state_id, &theme_rect, NULL);
 886     // Copy and mirror the result back into mem_dc.
 887     StretchBlt(hdc, r.x(), r.y(), r.width(), r.height(),
 888                 mem_dc, r.width()-1, 0, -r.width(), r.height(), SRCCOPY);
 889     return result;
 890   }
 891
 892   // For some reason, Windows uses the name DFCS_MENUARROWRIGHT to indicate a
 893   // left pointing arrow. This makes the following statement counterintuitive.
 894   UINT pfc_state = extra.pointing_right ? DFCS_MENUARROW : DFCS_MENUARROWRIGHT;
 895   return PaintFrameControl(hdc, rect, DFC_MENU, pfc_state, extra.is_selected,
 896                            state);
 897 }
 898
 899 HRESULT NativeThemeWin::PaintMenuBackground(HDC hdc,
 900                                             const gfx::Rect& rect) const {
 901   HANDLE handle = GetThemeHandle(MENU);
 902   RECT rect_win = rect.ToRECT();
 903   if (handle && draw_theme_) {
 904     HRESULT result = draw_theme_(handle, hdc, MENU_POPUPBACKGROUND, 0,
 905                                  &rect_win, NULL);
 906     FrameRect(hdc, &rect_win, GetSysColorBrush(COLOR_3DSHADOW));
 907     return result;
 908   }
 909
 910   FillRect(hdc, &rect_win, GetSysColorBrush(COLOR_MENU));
 911   DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT);
 912   return S_OK;
 913 }
 914
 915 HRESULT NativeThemeWin::PaintMenuCheck(
 916     HDC hdc,
 917     State state,
 918     const gfx::Rect& rect,
 919     const MenuCheckExtraParams& extra) const {
 920   HANDLE handle = GetThemeHandle(MENU);
 921   if (handle && draw_theme_) {
 922     const int state_id = extra.is_radio ?
 923         ((state == kDisabled) ? MC_BULLETDISABLED : MC_BULLETNORMAL) :
 924         ((state == kDisabled) ? MC_CHECKMARKDISABLED : MC_CHECKMARKNORMAL);
 925     RECT rect_win = rect.ToRECT();
 926     return draw_theme_(handle, hdc, MENU_POPUPCHECK, state_id, &rect_win, NULL);
 927   }
 928
 929   return PaintFrameControl(hdc, rect, DFC_MENU,
 930                            extra.is_radio ? DFCS_MENUBULLET : DFCS_MENUCHECK,
 931                            extra.is_selected, state);
 932 }
 933
 934 HRESULT NativeThemeWin::PaintMenuCheckBackground(HDC hdc,
 935                                                  State state,
 936                                                  const gfx::Rect& rect) const {
 937   HANDLE handle = GetThemeHandle(MENU);
 938   if (!handle || !draw_theme_)
 939     return S_OK;  // Nothing to do for background.
 940
 941   int state_id = state == kDisabled ? MCB_DISABLED : MCB_NORMAL;
 942   RECT rect_win = rect.ToRECT();
 943   return draw_theme_(handle, hdc, MENU_POPUPCHECKBACKGROUND, state_id,
 944                      &rect_win, NULL);
 945 }
 946
 947 HRESULT NativeThemeWin::PaintMenuItemBackground(
 948     HDC hdc,
 949     State state,
 950     const gfx::Rect& rect,
 951     const MenuItemExtraParams& extra) const {
 952   HANDLE handle = GetThemeHandle(MENU);
 953   RECT rect_win = rect.ToRECT();
 954   int state_id = MPI_NORMAL;
 955   switch (state) {
 956     case kDisabled:
 957       state_id = extra.is_selected ? MPI_DISABLEDHOT : MPI_DISABLED;
 958       break;
 959     case kHovered:
 960       state_id = MPI_HOT;
 961       break;
 962     case kNormal:
 963       break;
 964     case kPressed:
 965     case kNumStates:
 966       NOTREACHED();
 967       break;
 968   }
 969
 970   if (handle && draw_theme_)
 971     return draw_theme_(handle, hdc, MENU_POPUPITEM, state_id, &rect_win, NULL);
 972
 973   if (extra.is_selected)
 974     FillRect(hdc, &rect_win, GetSysColorBrush(COLOR_HIGHLIGHT));
 975   return S_OK;
 976 }
 977
 978 HRESULT NativeThemeWin::PaintPushButton(HDC hdc,
 979                                         Part part,
 980                                         State state,
 981                                         const gfx::Rect& rect,
 982                                         const ButtonExtraParams& extra) const {
 983   int state_id = extra.is_default ? PBS_DEFAULTED : PBS_NORMAL;
 984   switch (state) {
 985     case kDisabled:
 986       state_id = PBS_DISABLED;
 987       break;
 988     case kHovered:
 989       state_id = PBS_HOT;
 990       break;
 991     case kNormal:
 992       break;
 993     case kPressed:
 994       state_id = PBS_PRESSED;
 995       break;
 996     case kNumStates:
 997       NOTREACHED();
 998       break;
 999   }
1000
1001   RECT rect_win = rect.ToRECT();
1002   return PaintButton(hdc, state, extra, BP_PUSHBUTTON, state_id, &rect_win);
1003 }
1004
1005 HRESULT NativeThemeWin::PaintRadioButton(HDC hdc,
1006                                          Part part,
1007                                          State state,
1008                                          const gfx::Rect& rect,
1009                                          const ButtonExtraParams& extra) const {
1010   int state_id = extra.checked ? RBS_CHECKEDNORMAL : RBS_UNCHECKEDNORMAL;
1011   switch (state) {
1012     case kDisabled:
1013       state_id = extra.checked ? RBS_CHECKEDDISABLED : RBS_UNCHECKEDDISABLED;
1014       break;
1015     case kHovered:
1016       state_id = extra.checked ? RBS_CHECKEDHOT : RBS_UNCHECKEDHOT;
1017       break;
1018     case kNormal:
1019       break;
1020     case kPressed:
1021       state_id = extra.checked ? RBS_CHECKEDPRESSED : RBS_UNCHECKEDPRESSED;
1022       break;
1023     case kNumStates:
1024       NOTREACHED();
1025       break;
1026   }
1027
1028   RECT rect_win = rect.ToRECT();
1029   return PaintButton(hdc, state, extra, BP_RADIOBUTTON, state_id, &rect_win);
1030 }
1031
1032 HRESULT NativeThemeWin::PaintCheckbox(HDC hdc,
1033                                       Part part,
1034                                       State state,
1035                                       const gfx::Rect& rect,
1036                                       const ButtonExtraParams& extra) const {
1037   int state_id = extra.checked ?
1038       CBS_CHECKEDNORMAL :
1039       (extra.indeterminate ? CBS_MIXEDNORMAL : CBS_UNCHECKEDNORMAL);
1040   switch (state) {
1041     case kDisabled:
1042       state_id = extra.checked ?
1043           CBS_CHECKEDDISABLED :
1044           (extra.indeterminate ? CBS_MIXEDDISABLED : CBS_UNCHECKEDDISABLED);
1045       break;
1046     case kHovered:
1047       state_id = extra.checked ?
1048           CBS_CHECKEDHOT :
1049           (extra.indeterminate ? CBS_MIXEDHOT : CBS_UNCHECKEDHOT);
1050       break;
1051     case kNormal:
1052       break;
1053     case kPressed:
1054       state_id = extra.checked ?
1055           CBS_CHECKEDPRESSED :
1056           (extra.indeterminate ? CBS_MIXEDPRESSED : CBS_UNCHECKEDPRESSED);
1057       break;
1058     case kNumStates:
1059       NOTREACHED();
1060       break;
1061   }
1062
1063   RECT rect_win = rect.ToRECT();
1064   return PaintButton(hdc, state, extra, BP_CHECKBOX, state_id, &rect_win);
1065 }
1066
1067 HRESULT NativeThemeWin::PaintMenuList(HDC hdc,
1068                                       State state,
1069                                       const gfx::Rect& rect,
1070                                       const MenuListExtraParams& extra) const {
1071   HANDLE handle = GetThemeHandle(MENULIST);
1072   RECT rect_win = rect.ToRECT();
1073   int state_id = CBXS_NORMAL;
1074   switch (state) {
1075     case kDisabled:
1076       state_id = CBXS_DISABLED;
1077       break;
1078     case kHovered:
1079       state_id = CBXS_HOT;
1080       break;
1081     case kNormal:
1082       break;
1083     case kPressed:
1084       state_id = CBXS_PRESSED;
1085       break;
1086     case kNumStates:
1087       NOTREACHED();
1088       break;
1089   }
1090
1091   if (handle && draw_theme_)
1092     return draw_theme_(handle, hdc, CP_DROPDOWNBUTTON, state_id, &rect_win,
1093                        NULL);
1094
1095   // Draw it manually.
1096   DrawFrameControl(hdc, &rect_win, DFC_SCROLL,
1097                    DFCS_SCROLLCOMBOBOX | extra.classic_state);
1098   return S_OK;
1099 }
1100
1101 HRESULT NativeThemeWin::PaintScrollbarArrow(
1102     HDC hdc,
1103     Part part,
1104     State state,
1105     const gfx::Rect& rect,
1106     const ScrollbarArrowExtraParams& extra) const {
1107   static const int state_id_matrix[4][kNumStates] = {
1108       ABS_DOWNDISABLED, ABS_DOWNHOT, ABS_DOWNNORMAL, ABS_DOWNPRESSED,
1109       ABS_LEFTDISABLED, ABS_LEFTHOT, ABS_LEFTNORMAL, ABS_LEFTPRESSED,
1110       ABS_RIGHTDISABLED, ABS_RIGHTHOT, ABS_RIGHTNORMAL, ABS_RIGHTPRESSED,
1111       ABS_UPDISABLED, ABS_UPHOT, ABS_UPNORMAL, ABS_UPPRESSED
1112   };
1113   HANDLE handle = GetThemeHandle(SCROLLBAR);
1114   RECT rect_win = rect.ToRECT();
1115   if (handle && draw_theme_) {
1116     int index = part - kScrollbarDownArrow;
1117     DCHECK_GE(index, 0);
1118     DCHECK_LT(static_cast<size_t>(index), arraysize(state_id_matrix));
1119     int state_id = state_id_matrix[index][state];
1120
1121     // Hovering means that the cursor is over the scroolbar, but not over the
1122     // specific arrow itself.  We don't want to show it "hot" mode, but only
1123     // in "hover" mode.
1124     if (state == kHovered && extra.is_hovering) {
1125       switch (part) {
1126         case kScrollbarDownArrow:
1127           state_id = ABS_DOWNHOVER;
1128           break;
1129         case kScrollbarLeftArrow:
1130           state_id = ABS_LEFTHOVER;
1131           break;
1132         case kScrollbarRightArrow:
1133           state_id = ABS_RIGHTHOVER;
1134           break;
1135         case kScrollbarUpArrow:
1136           state_id = ABS_UPHOVER;
1137           break;
1138         default:
1139           NOTREACHED();
1140           break;
1141       }
1142     }
1143     return PaintScaledTheme(handle, hdc, SBP_ARROWBTN, state_id, rect);
1144   }
1145
1146   int classic_state = DFCS_SCROLLDOWN;
1147   switch (part) {
1148     case kScrollbarDownArrow:
1149       break;
1150     case kScrollbarLeftArrow:
1151       classic_state = DFCS_SCROLLLEFT;
1152       break;
1153     case kScrollbarRightArrow:
1154       classic_state = DFCS_SCROLLRIGHT;
1155       break;
1156     case kScrollbarUpArrow:
1157       classic_state = DFCS_SCROLLUP;
1158       break;
1159     default:
1160       NOTREACHED();
1161       break;
1162   }
1163   switch (state) {
1164     case kDisabled:
1165       classic_state |= DFCS_INACTIVE;
1166       break;
1167     case kHovered:
1168       classic_state |= DFCS_HOT;
1169       break;
1170     case kNormal:
1171       break;
1172     case kPressed:
1173       classic_state |= DFCS_PUSHED;
1174       break;
1175     case kNumStates:
1176       NOTREACHED();
1177       break;
1178   }
1179   DrawFrameControl(hdc, &rect_win, DFC_SCROLL, classic_state);
1180   return S_OK;
1181 }
1182
1183 HRESULT NativeThemeWin::PaintScrollbarThumb(
1184     HDC hdc,
1185     Part part,
1186     State state,
1187     const gfx::Rect& rect,
1188     const ScrollbarThumbExtraParams& extra) const {
1189   HANDLE handle = GetThemeHandle(SCROLLBAR);
1190   RECT rect_win = rect.ToRECT();
1191
1192   int part_id = SBP_THUMBBTNVERT;
1193   switch (part) {
1194     case kScrollbarHorizontalThumb:
1195       part_id = SBP_THUMBBTNHORZ;
1196       break;
1197     case kScrollbarVerticalThumb:
1198       break;
1199     case kScrollbarHorizontalGripper:
1200       part_id = SBP_GRIPPERHORZ;
1201       break;
1202     case kScrollbarVerticalGripper:
1203       part_id = SBP_GRIPPERVERT;
1204       break;
1205     default:
1206       NOTREACHED();
1207       break;
1208   }
1209
1210   int state_id = SCRBS_NORMAL;
1211   switch (state) {
1212     case kDisabled:
1213       state_id = SCRBS_DISABLED;
1214       break;
1215     case kHovered:
1216       state_id = extra.is_hovering ? SCRBS_HOVER : SCRBS_HOT;
1217       break;
1218     case kNormal:
1219       break;
1220     case kPressed:
1221       state_id = SCRBS_PRESSED;
1222       break;
1223     case kNumStates:
1224       NOTREACHED();
1225       break;
1226   }
1227
1228   if (handle && draw_theme_)
1229     return PaintScaledTheme(handle, hdc, part_id, state_id, rect);
1230
1231   // Draw it manually.
1232   if ((part_id == SBP_THUMBBTNHORZ) || (part_id == SBP_THUMBBTNVERT))
1233     DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT | BF_MIDDLE);
1234   // Classic mode doesn't have a gripper.
1235   return S_OK;
1236 }
1237
1238 HRESULT NativeThemeWin::PaintScrollbarTrack(
1239     SkCanvas* canvas,
1240     HDC hdc,
1241     Part part,
1242     State state,
1243     const gfx::Rect& rect,
1244     const ScrollbarTrackExtraParams& extra) const {
1245   HANDLE handle = GetThemeHandle(SCROLLBAR);
1246   RECT rect_win = rect.ToRECT();
1247
1248   const int part_id = extra.is_upper ?
1249       ((part == kScrollbarHorizontalTrack) ?
1250           SBP_UPPERTRACKHORZ : SBP_UPPERTRACKVERT) :
1251       ((part == kScrollbarHorizontalTrack) ?
1252           SBP_LOWERTRACKHORZ : SBP_LOWERTRACKVERT);
1253
1254   int state_id = SCRBS_NORMAL;
1255   switch (state) {
1256     case kDisabled:
1257       state_id = SCRBS_DISABLED;
1258       break;
1259     case kHovered:
1260       state_id = SCRBS_HOVER;
1261       break;
1262     case kNormal:
1263       break;
1264     case kPressed:
1265       state_id = SCRBS_PRESSED;
1266       break;
1267     case kNumStates:
1268       NOTREACHED();
1269       break;
1270   }
1271
1272   if (handle && draw_theme_)
1273     return draw_theme_(handle, hdc, part_id, state_id, &rect_win, NULL);
1274
1275   // Draw it manually.
1276   if ((system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_3DFACE]) &&
1277       (system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_WINDOW])) {
1278     FillRect(hdc, &rect_win, reinterpret_cast<HBRUSH>(COLOR_SCROLLBAR + 1));
1279   } else {
1280     SkPaint paint;
1281     RECT align_rect = gfx::Rect(extra.track_x, extra.track_y, extra.track_width,
1282                                 extra.track_height).ToRECT();
1283     SetCheckerboardShader(&paint, align_rect);
1284     canvas->drawIRect(skia::RECTToSkIRect(rect_win), paint);
1285   }
1286   if (extra.classic_state & DFCS_PUSHED)
1287     InvertRect(hdc, &rect_win);
1288   return S_OK;
1289 }
1290
1291 HRESULT NativeThemeWin::PaintSpinButton(
1292     HDC hdc,
1293     Part part,
1294     State state,
1295     const gfx::Rect& rect,
1296     const InnerSpinButtonExtraParams& extra) const {
1297   HANDLE handle = GetThemeHandle(SPIN);
1298   RECT rect_win = rect.ToRECT();
1299   int part_id = extra.spin_up ? SPNP_UP : SPNP_DOWN;
1300   int state_id = extra.spin_up ? UPS_NORMAL : DNS_NORMAL;
1301   switch (state) {
1302     case kDisabled:
1303       state_id = extra.spin_up ? UPS_DISABLED : DNS_DISABLED;
1304       break;
1305     case kHovered:
1306       state_id = extra.spin_up ? UPS_HOT : DNS_HOT;
1307       break;
1308     case kNormal:
1309       break;
1310     case kPressed:
1311       state_id = extra.spin_up ? UPS_PRESSED : DNS_PRESSED;
1312       break;
1313     case kNumStates:
1314       NOTREACHED();
1315       break;
1316   }
1317
1318   if (handle && draw_theme_)
1319     return draw_theme_(handle, hdc, part_id, state_id, &rect_win, NULL);
1320   DrawFrameControl(hdc, &rect_win, DFC_SCROLL, extra.classic_state);
1321   return S_OK;
1322 }
1323
1324 HRESULT NativeThemeWin::PaintTrackbar(
1325     SkCanvas* canvas,
1326     HDC hdc,
1327     Part part,
1328     State state,
1329     const gfx::Rect& rect,
1330     const TrackbarExtraParams& extra) const {
1331   const int part_id = extra.vertical ?
1332       ((part == kTrackbarTrack) ? TKP_TRACKVERT : TKP_THUMBVERT) :
1333       ((part == kTrackbarTrack) ? TKP_TRACK : TKP_THUMBBOTTOM);
1334
1335   int state_id = TUS_NORMAL;
1336   switch (state) {
1337     case kDisabled:
1338       state_id = TUS_DISABLED;
1339       break;
1340     case kHovered:
1341       state_id = TUS_HOT;
1342       break;
1343     case kNormal:
1344       break;
1345     case kPressed:
1346       state_id = TUS_PRESSED;
1347       break;
1348     case kNumStates:
1349       NOTREACHED();
1350       break;
1351   }
1352
1353   // Make the channel be 4 px thick in the center of the supplied rect.  (4 px
1354   // matches what XP does in various menus; GetThemePartSize() doesn't seem to
1355   // return good values here.)
1356   RECT rect_win = rect.ToRECT();
1357   RECT channel_rect = rect.ToRECT();
1358   const int channel_thickness = 4;
1359   if (part_id == TKP_TRACK) {
1360     channel_rect.top +=
1361         ((channel_rect.bottom - channel_rect.top - channel_thickness) / 2);
1362     channel_rect.bottom = channel_rect.top + channel_thickness;
1363   } else if (part_id == TKP_TRACKVERT) {
1364     channel_rect.left +=
1365         ((channel_rect.right - channel_rect.left - channel_thickness) / 2);
1366     channel_rect.right = channel_rect.left + channel_thickness;
1367   }  // else this isn't actually a channel, so |channel_rect| == |rect|.
1368
1369   HANDLE handle = GetThemeHandle(TRACKBAR);
1370   if (handle && draw_theme_)
1371     return draw_theme_(handle, hdc, part_id, state_id, &channel_rect, NULL);
1372
1373   // Classic mode, draw it manually.
1374   if ((part_id == TKP_TRACK) || (part_id == TKP_TRACKVERT)) {
1375     DrawEdge(hdc, &channel_rect, EDGE_SUNKEN, BF_RECT);
1376   } else if (part_id == TKP_THUMBVERT) {
1377     DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT | BF_SOFT | BF_MIDDLE);
1378   } else {
1379     // Split rect into top and bottom pieces.
1380     RECT top_section = rect.ToRECT();
1381     RECT bottom_section = rect.ToRECT();
1382     top_section.bottom -= ((bottom_section.right - bottom_section.left) / 2);
1383     bottom_section.top = top_section.bottom;
1384     DrawEdge(hdc, &top_section, EDGE_RAISED,
1385              BF_LEFT | BF_TOP | BF_RIGHT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
1386
1387     // Split triangular piece into two diagonals.
1388     RECT& left_half = bottom_section;
1389     RECT right_half = bottom_section;
1390     right_half.left += ((bottom_section.right - bottom_section.left) / 2);
1391     left_half.right = right_half.left;
1392     DrawEdge(hdc, &left_half, EDGE_RAISED,
1393              BF_DIAGONAL_ENDTOPLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
1394     DrawEdge(hdc, &right_half, EDGE_RAISED,
1395              BF_DIAGONAL_ENDBOTTOMLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
1396
1397     // If the button is pressed, draw hatching.
1398     if (extra.classic_state & DFCS_PUSHED) {
1399       SkPaint paint;
1400       SetCheckerboardShader(&paint, rect_win);
1401
1402       // Fill all three pieces with the pattern.
1403       canvas->drawIRect(skia::RECTToSkIRect(top_section), paint);
1404
1405       SkScalar left_triangle_top = SkIntToScalar(left_half.top);
1406       SkScalar left_triangle_right = SkIntToScalar(left_half.right);
1407       SkPath left_triangle;
1408       left_triangle.moveTo(SkIntToScalar(left_half.left), left_triangle_top);
1409       left_triangle.lineTo(left_triangle_right, left_triangle_top);
1410       left_triangle.lineTo(left_triangle_right,
1411                            SkIntToScalar(left_half.bottom));
1412       left_triangle.close();
1413       canvas->drawPath(left_triangle, paint);
1414
1415       SkScalar right_triangle_left = SkIntToScalar(right_half.left);
1416       SkScalar right_triangle_top = SkIntToScalar(right_half.top);
1417       SkPath right_triangle;
1418       right_triangle.moveTo(right_triangle_left, right_triangle_top);
1419       right_triangle.lineTo(SkIntToScalar(right_half.right),
1420                             right_triangle_top);
1421       right_triangle.lineTo(right_triangle_left,
1422                             SkIntToScalar(right_half.bottom));
1423       right_triangle.close();
1424       canvas->drawPath(right_triangle, paint);
1425     }
1426   }
1427   return S_OK;
1428 }
1429
1430 HRESULT NativeThemeWin::PaintProgressBar(
1431     HDC hdc,
1432     const gfx::Rect& rect,
1433     const ProgressBarExtraParams& extra) const {
1434   // There is no documentation about the animation speed, frame-rate, nor
1435   // size of moving overlay of the indeterminate progress bar.
1436   // So we just observed real-world programs and guessed following parameters.
1437   const int kDeterminateOverlayPixelsPerSecond = 300;
1438   const int kDeterminateOverlayWidth = 120;
1439   const int kIndeterminateOverlayPixelsPerSecond =  175;
1440   const int kVistaIndeterminateOverlayWidth = 120;
1441   const int kXPIndeterminateOverlayWidth = 55;
1442   // The thickness of the bar frame inside |value_rect|
1443   const int kXPBarPadding = 3;
1444
1445   RECT bar_rect = rect.ToRECT();
1446   RECT value_rect = gfx::Rect(extra.value_rect_x,
1447                               extra.value_rect_y,
1448                               extra.value_rect_width,
1449                               extra.value_rect_height).ToRECT();
1450
1451   HANDLE handle = GetThemeHandle(PROGRESS);
1452   if (!handle || !draw_theme_ || !draw_theme_ex_) {
1453     FillRect(hdc, &bar_rect, GetSysColorBrush(COLOR_BTNFACE));
1454     FillRect(hdc, &value_rect, GetSysColorBrush(COLOR_BTNSHADOW));
1455     DrawEdge(hdc, &bar_rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1456     return S_OK;
1457   }
1458
1459   draw_theme_(handle, hdc, PP_BAR, 0, &bar_rect, NULL);
1460
1461   bool pre_vista = base::win::GetVersion() < base::win::VERSION_VISTA;
1462   int bar_width = bar_rect.right - bar_rect.left;
1463   if (!extra.determinate) {
1464     // The glossy overlay for the indeterminate progress bar has a small pause
1465     // after each animation. We emulate this by adding an invisible margin the
1466     // animation has to traverse.
1467     int width_with_margin = bar_width + kIndeterminateOverlayPixelsPerSecond;
1468     int overlay_width = pre_vista ?
1469         kXPIndeterminateOverlayWidth : kVistaIndeterminateOverlayWidth;
1470     RECT overlay_rect = bar_rect;
1471     overlay_rect.left += ComputeAnimationProgress(
1472         width_with_margin, overlay_width, kIndeterminateOverlayPixelsPerSecond,
1473         extra.animated_seconds);
1474     overlay_rect.right = overlay_rect.left + overlay_width;
1475     if (pre_vista) {
1476       RECT shrunk_rect = InsetRect(&overlay_rect, kXPBarPadding);
1477       RECT shrunk_bar_rect = InsetRect(&bar_rect, kXPBarPadding);
1478       draw_theme_(handle, hdc, PP_CHUNK, 0, &shrunk_rect, &shrunk_bar_rect);
1479     } else {
1480       draw_theme_(handle, hdc, PP_MOVEOVERLAY, 0, &overlay_rect, &bar_rect);
1481     }
1482     return S_OK;
1483   }
1484
1485   // We care about the direction here because PP_CHUNK painting is asymmetric.
1486   // TODO(morrita): This RTL guess can be wrong.  We should pass in the
1487   // direction from WebKit.
1488   const DTBGOPTS value_draw_options = {
1489     sizeof(DTBGOPTS),
1490     (bar_rect.right == value_rect.right && bar_rect.left != value_rect.left) ?
1491         DTBG_MIRRORDC : 0,
1492     bar_rect
1493   };
1494   if (pre_vista) {
1495     // On XP, the progress bar is chunk-style and has no glossy effect.  We need
1496     // to shrink the destination rect to fit the part inside the bar with an
1497     // appropriate margin.
1498     RECT shrunk_value_rect = InsetRect(&value_rect, kXPBarPadding);
1499     draw_theme_ex_(handle, hdc, PP_CHUNK, 0, &shrunk_value_rect,
1500                    &value_draw_options);
1501   } else  {
1502     // On Vista or later, the progress bar part has a single-block value part
1503     // and a glossy effect.  The value part has exactly same height as the bar
1504     // part, so we don't need to shrink the rect.
1505     draw_theme_ex_(handle, hdc, PP_FILL, 0, &value_rect, &value_draw_options);
1506
1507     RECT overlay_rect = value_rect;
1508     overlay_rect.left += ComputeAnimationProgress(
1509         bar_width, kDeterminateOverlayWidth, kDeterminateOverlayPixelsPerSecond,
1510         extra.animated_seconds);
1511     overlay_rect.right = overlay_rect.left + kDeterminateOverlayWidth;
1512     draw_theme_(handle, hdc, PP_MOVEOVERLAY, 0, &overlay_rect, &value_rect);
1513   }
1514   return S_OK;
1515 }
1516
1517 HRESULT NativeThemeWin::PaintWindowResizeGripper(HDC hdc,
1518                                                  const gfx::Rect& rect) const {
1519   HANDLE handle = GetThemeHandle(STATUS);
1520   RECT rect_win = rect.ToRECT();
1521   if (handle && draw_theme_) {
1522     // Paint the status bar gripper.  There doesn't seem to be a standard
1523     // gripper in Windows for the space between scrollbars.  This is pretty
1524     // close, but it's supposed to be painted over a status bar.
1525     return draw_theme_(handle, hdc, SP_GRIPPER, 0, &rect_win, NULL);
1526   }
1527
1528   // Draw a windows classic scrollbar gripper.
1529   DrawFrameControl(hdc, &rect_win, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
1530   return S_OK;
1531 }
1532
1533 HRESULT NativeThemeWin::PaintTabPanelBackground(HDC hdc,
1534                                                 const gfx::Rect& rect) const {
1535   HANDLE handle = GetThemeHandle(TAB);
1536   RECT rect_win = rect.ToRECT();
1537   if (handle && draw_theme_)
1538     return draw_theme_(handle, hdc, TABP_BODY, 0, &rect_win, NULL);
1539
1540   // Classic just renders a flat color background.
1541   FillRect(hdc, &rect_win, reinterpret_cast<HBRUSH>(COLOR_3DFACE + 1));
1542   return S_OK;
1543 }
1544
1545 HRESULT NativeThemeWin::PaintTextField(
1546     HDC hdc,
1547     Part part,
1548     State state,
1549     const gfx::Rect& rect,
1550     const TextFieldExtraParams& extra) const {
1551   int state_id = ETS_NORMAL;
1552   switch (state) {
1553     case kDisabled:
1554       state_id = ETS_DISABLED;
1555       break;
1556     case kHovered:
1557       state_id = ETS_HOT;
1558       break;
1559     case kNormal:
1560       if (extra.is_read_only)
1561         state_id = ETS_READONLY;
1562       else if (extra.is_focused)
1563         state_id = ETS_FOCUSED;
1564       break;
1565     case kPressed:
1566       state_id = ETS_SELECTED;
1567       break;
1568     case kNumStates:
1569       NOTREACHED();
1570       break;
1571   }
1572
1573   RECT rect_win = rect.ToRECT();
1574   return PaintTextField(hdc, EP_EDITTEXT, state_id, extra.classic_state,
1575                         &rect_win,
1576                         skia::SkColorToCOLORREF(extra.background_color),
1577                         extra.fill_content_area, extra.draw_edges);
1578 }
1579
1580 HRESULT NativeThemeWin::PaintTextField(HDC hdc,
1581                                        int part_id,
1582                                        int state_id,
1583                                        int classic_state,
1584                                        RECT* rect,
1585                                        COLORREF color,
1586                                        bool fill_content_area,
1587                                        bool draw_edges) const {
1588   // TODO(ojan): http://b/1210017 Figure out how to give the ability to
1589   // exclude individual edges from being drawn.
1590
1591   HANDLE handle = GetThemeHandle(TEXTFIELD);
1592   // TODO(mpcomplete): can we detect if the color is specified by the user,
1593   // and if not, just use the system color?
1594   // CreateSolidBrush() accepts a RGB value but alpha must be 0.
1595   base::win::ScopedGDIObject<HBRUSH> bg_brush(CreateSolidBrush(color));
1596   // DrawThemeBackgroundEx was introduced in XP SP2, so that it's possible
1597   // draw_theme_ex_ is NULL and draw_theme_ is non-null.
1598   if (!handle || (!draw_theme_ex_ && (!draw_theme_ || !draw_edges))) {
1599     // Draw it manually.
1600     if (draw_edges)
1601       DrawEdge(hdc, rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1602
1603     if (fill_content_area) {
1604       FillRect(hdc, rect, (classic_state & DFCS_INACTIVE) ?
1605                    reinterpret_cast<HBRUSH>(COLOR_BTNFACE + 1) : bg_brush);
1606     }
1607     return S_OK;
1608   }
1609
1610   static const DTBGOPTS omit_border_options = {
1611     sizeof(DTBGOPTS),
1612     DTBG_OMITBORDER,
1613     { 0, 0, 0, 0 }
1614   };
1615   HRESULT hr = draw_theme_ex_ ?
1616     draw_theme_ex_(handle, hdc, part_id, state_id, rect,
1617                    draw_edges ? NULL : &omit_border_options) :
1618     draw_theme_(handle, hdc, part_id, state_id, rect, NULL);
1619
1620   // TODO(maruel): Need to be fixed if get_theme_content_rect_ is NULL.
1621   if (fill_content_area && get_theme_content_rect_) {
1622     RECT content_rect;
1623     hr = get_theme_content_rect_(handle, hdc, part_id, state_id, rect,
1624                                   &content_rect);
1625     FillRect(hdc, &content_rect, bg_brush);
1626   }
1627   return hr;
1628 }
1629
1630 HRESULT NativeThemeWin::PaintScaledTheme(HANDLE theme,
1631                                          HDC hdc,
1632                                          int part_id,
1633                                          int state_id,
1634                                          const gfx::Rect& rect) const {
1635   // Correct the scaling and positioning of sub-components such as scrollbar
1636   // arrows and thumb grippers in the event that the world transform applies
1637   // scaling (e.g. in high-DPI mode).
1638   XFORM save_transform;
1639   if (GetWorldTransform(hdc, &save_transform)) {
1640     float scale = save_transform.eM11;
1641     if (scale != 1 && save_transform.eM12 == 0) {
1642       ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
1643       gfx::Rect scaled_rect(gfx::ToEnclosedRect(gfx::ScaleRect(rect, scale)));
1644       scaled_rect.Offset(save_transform.eDx, save_transform.eDy);
1645       RECT bounds = scaled_rect.ToRECT();
1646       HRESULT result = draw_theme_(theme, hdc, part_id, state_id, &bounds,
1647                                    NULL);
1648       SetWorldTransform(hdc, &save_transform);
1649       return result;
1650     }
1651   }
1652   RECT bounds = rect.ToRECT();
1653   return draw_theme_(theme, hdc, part_id, state_id, &bounds, NULL);
1654 }
1655
1656 // static
1657 NativeThemeWin::ThemeName NativeThemeWin::GetThemeName(Part part) {
1658   switch (part) {
1659     case kCheckbox:
1660     case kPushButton:
1661     case kRadio:
1662       return BUTTON;
1663     case kInnerSpinButton:
1664       return SPIN;
1665     case kMenuList:
1666     case kMenuCheck:
1667     case kMenuPopupArrow:
1668     case kMenuPopupGutter:
1669     case kMenuPopupSeparator:
1670       return MENU;
1671     case kProgressBar:
1672       return PROGRESS;
1673     case kScrollbarDownArrow:
1674     case kScrollbarLeftArrow:
1675     case kScrollbarRightArrow:
1676     case kScrollbarUpArrow:
1677     case kScrollbarHorizontalThumb:
1678     case kScrollbarVerticalThumb:
1679     case kScrollbarHorizontalTrack:
1680     case kScrollbarVerticalTrack:
1681       return SCROLLBAR;
1682     case kSliderTrack:
1683     case kSliderThumb:
1684       return TRACKBAR;
1685     case kTextField:
1686       return TEXTFIELD;
1687     case kWindowResizeGripper:
1688       return STATUS;
1689     case kComboboxArrow:
1690     case kMenuCheckBackground:
1691     case kMenuPopupBackground:
1692     case kMenuItemBackground:
1693     case kScrollbarHorizontalGripper:
1694     case kScrollbarVerticalGripper:
1695     case kScrollbarCorner:
1696     case kTabPanelBackground:
1697     case kTrackbarThumb:
1698     case kTrackbarTrack:
1699     case kMaxPart:
1700       NOTREACHED();
1701   }
1702   return LAST;
1703 }
1704
1705 // static
1706 int NativeThemeWin::GetWindowsPart(Part part,
1707                                    State state,
1708                                    const ExtraParams& extra) {
1709   switch (part) {
1710     case kCheckbox:
1711       return BP_CHECKBOX;
1712     case kMenuCheck:
1713       return MENU_POPUPCHECK;
1714     case kMenuPopupArrow:
1715       return MENU_POPUPSUBMENU;
1716     case kMenuPopupGutter:
1717       return MENU_POPUPGUTTER;
1718     case kMenuPopupSeparator:
1719       return MENU_POPUPSEPARATOR;
1720     case kPushButton:
1721       return BP_PUSHBUTTON;
1722     case kRadio:
1723       return BP_RADIOBUTTON;
1724     case kScrollbarDownArrow:
1725     case kScrollbarLeftArrow:
1726     case kScrollbarRightArrow:
1727     case kScrollbarUpArrow:
1728       return SBP_ARROWBTN;
1729     case kScrollbarHorizontalThumb:
1730       return SBP_THUMBBTNHORZ;
1731     case kScrollbarVerticalThumb:
1732       return SBP_THUMBBTNVERT;
1733     case kWindowResizeGripper:
1734       return SP_GRIPPER;
1735     case kComboboxArrow:
1736     case kInnerSpinButton:
1737     case kMenuList:
1738     case kMenuCheckBackground:
1739     case kMenuPopupBackground:
1740     case kMenuItemBackground:
1741     case kProgressBar:
1742     case kScrollbarHorizontalTrack:
1743     case kScrollbarVerticalTrack:
1744     case kScrollbarHorizontalGripper:
1745     case kScrollbarVerticalGripper:
1746     case kScrollbarCorner:
1747     case kSliderTrack:
1748     case kSliderThumb:
1749     case kTabPanelBackground:
1750     case kTextField:
1751     case kTrackbarThumb:
1752     case kTrackbarTrack:
1753     case kMaxPart:
1754       NOTREACHED();
1755   }
1756   return 0;
1757 }
1758
1759 int NativeThemeWin::GetWindowsState(Part part,
1760                                     State state,
1761                                     const ExtraParams& extra) {
1762   switch (part) {
1763     case kCheckbox:
1764       switch (state) {
1765         case kDisabled:
1766           return CBS_UNCHECKEDDISABLED;
1767         case kHovered:
1768           return CBS_UNCHECKEDHOT;
1769         case kNormal:
1770           return CBS_UNCHECKEDNORMAL;
1771         case kPressed:
1772           return CBS_UNCHECKEDPRESSED;
1773         case kNumStates:
1774           NOTREACHED();
1775           return 0;
1776       }
1777     case kMenuCheck:
1778       switch (state) {
1779         case kDisabled:
1780           return extra.menu_check.is_radio ?
1781               MC_BULLETDISABLED : MC_CHECKMARKDISABLED;
1782         case kHovered:
1783         case kNormal:
1784         case kPressed:
1785           return extra.menu_check.is_radio ?
1786               MC_BULLETNORMAL : MC_CHECKMARKNORMAL;
1787         case kNumStates:
1788           NOTREACHED();
1789           return 0;
1790       }
1791     case kMenuPopupArrow:
1792     case kMenuPopupGutter:
1793     case kMenuPopupSeparator:
1794       switch (state) {
1795         case kDisabled:
1796           return MBI_DISABLED;
1797         case kHovered:
1798           return MBI_HOT;
1799         case kNormal:
1800           return MBI_NORMAL;
1801         case kPressed:
1802           return MBI_PUSHED;
1803         case kNumStates:
1804           NOTREACHED();
1805           return 0;
1806       }
1807     case kPushButton:
1808       switch (state) {
1809         case kDisabled:
1810           return PBS_DISABLED;
1811         case kHovered:
1812           return PBS_HOT;
1813         case kNormal:
1814           return PBS_NORMAL;
1815         case kPressed:
1816           return PBS_PRESSED;
1817         case kNumStates:
1818           NOTREACHED();
1819           return 0;
1820       }
1821     case kRadio:
1822       switch (state) {
1823         case kDisabled:
1824           return RBS_UNCHECKEDDISABLED;
1825         case kHovered:
1826           return RBS_UNCHECKEDHOT;
1827         case kNormal:
1828           return RBS_UNCHECKEDNORMAL;
1829         case kPressed:
1830           return RBS_UNCHECKEDPRESSED;
1831         case kNumStates:
1832           NOTREACHED();
1833           return 0;
1834       }
1835     case kScrollbarDownArrow:
1836       switch (state) {
1837         case kDisabled:
1838           return ABS_DOWNDISABLED;
1839         case kHovered:
1840           // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
1841           return base::win::GetVersion() < base::win::VERSION_VISTA ?
1842               ABS_DOWNHOT : ABS_DOWNHOVER;
1843         case kNormal:
1844           return ABS_DOWNNORMAL;
1845         case kPressed:
1846           return ABS_DOWNPRESSED;
1847         case kNumStates:
1848           NOTREACHED();
1849           return 0;
1850       }
1851     case kScrollbarLeftArrow:
1852       switch (state) {
1853         case kDisabled:
1854           return ABS_LEFTDISABLED;
1855         case kHovered:
1856           // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
1857           return base::win::GetVersion() < base::win::VERSION_VISTA ?
1858               ABS_LEFTHOT : ABS_LEFTHOVER;
1859         case kNormal:
1860           return ABS_LEFTNORMAL;
1861         case kPressed:
1862           return ABS_LEFTPRESSED;
1863         case kNumStates:
1864           NOTREACHED();
1865           return 0;
1866       }
1867     case kScrollbarRightArrow:
1868       switch (state) {
1869         case kDisabled:
1870           return ABS_RIGHTDISABLED;
1871         case kHovered:
1872           // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
1873           return base::win::GetVersion() < base::win::VERSION_VISTA ?
1874               ABS_RIGHTHOT : ABS_RIGHTHOVER;
1875         case kNormal:
1876           return ABS_RIGHTNORMAL;
1877         case kPressed:
1878           return ABS_RIGHTPRESSED;
1879         case kNumStates:
1880           NOTREACHED();
1881           return 0;
1882       }
1883       break;
1884     case kScrollbarUpArrow:
1885       switch (state) {
1886         case kDisabled:
1887           return ABS_UPDISABLED;
1888         case kHovered:
1889           // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
1890           return base::win::GetVersion() < base::win::VERSION_VISTA ?
1891               ABS_UPHOT : ABS_UPHOVER;
1892         case kNormal:
1893           return ABS_UPNORMAL;
1894         case kPressed:
1895           return ABS_UPPRESSED;
1896         case kNumStates:
1897           NOTREACHED();
1898           return 0;
1899       }
1900       break;
1901     case kScrollbarHorizontalThumb:
1902     case kScrollbarVerticalThumb:
1903       switch (state) {
1904         case kDisabled:
1905           return SCRBS_DISABLED;
1906         case kHovered:
1907           // Mimic WebKit's behaviour in ScrollbarThemeChromiumWin.cpp.
1908           return base::win::GetVersion() < base::win::VERSION_VISTA ?
1909               SCRBS_HOT : SCRBS_HOVER;
1910         case kNormal:
1911           return SCRBS_NORMAL;
1912         case kPressed:
1913           return SCRBS_PRESSED;
1914         case kNumStates:
1915           NOTREACHED();
1916           return 0;
1917       }
1918     case kWindowResizeGripper:
1919       switch (state) {
1920         case kDisabled:
1921         case kHovered:
1922         case kNormal:
1923         case kPressed:
1924           return 1;  // gripper has no windows state
1925         case kNumStates:
1926           NOTREACHED();
1927           return 0;
1928       }
1929     case kComboboxArrow:
1930     case kInnerSpinButton:
1931     case kMenuList:
1932     case kMenuCheckBackground:
1933     case kMenuPopupBackground:
1934     case kMenuItemBackground:
1935     case kProgressBar:
1936     case kScrollbarHorizontalTrack:
1937     case kScrollbarVerticalTrack:
1938     case kScrollbarHorizontalGripper:
1939     case kScrollbarVerticalGripper:
1940     case kScrollbarCorner:
1941     case kSliderTrack:
1942     case kSliderThumb:
1943     case kTabPanelBackground:
1944     case kTextField:
1945     case kTrackbarThumb:
1946     case kTrackbarTrack:
1947     case kMaxPart:
1948       NOTREACHED();
1949   }
1950   return 0;
1951 }
1952
1953 HRESULT NativeThemeWin::GetThemeInt(ThemeName theme,
1954                                     int part_id,
1955                                     int state_id,
1956                                     int prop_id,
1957                                     int *value) const {
1958   HANDLE handle = GetThemeHandle(theme);
1959   return (handle && get_theme_int_) ?
1960       get_theme_int_(handle, part_id, state_id, prop_id, value) : E_NOTIMPL;
1961 }
1962
1963 HRESULT NativeThemeWin::PaintFrameControl(HDC hdc,
1964                                           const gfx::Rect& rect,
1965                                           UINT type,
1966                                           UINT state,
1967                                           bool is_selected,
1968                                           State control_state) const {
1969   const int width = rect.width();
1970   const int height = rect.height();
1971
1972   // DrawFrameControl for menu arrow/check wants a monochrome bitmap.
1973   base::win::ScopedBitmap mask_bitmap(CreateBitmap(width, height, 1, 1, NULL));
1974
1975   if (mask_bitmap == NULL)
1976     return E_OUTOFMEMORY;
1977
1978   base::win::ScopedCreateDC bitmap_dc(CreateCompatibleDC(NULL));
1979   base::win::ScopedSelectObject select_bitmap(bitmap_dc, mask_bitmap);
1980   RECT local_rect = { 0, 0, width, height };
1981   DrawFrameControl(bitmap_dc, &local_rect, type, state);
1982
1983   // We're going to use BitBlt with a b&w mask. This results in using the dest
1984   // dc's text color for the black bits in the mask, and the dest dc's
1985   // background color for the white bits in the mask. DrawFrameControl draws the
1986   // check in black, and the background in white.
1987   int bg_color_key = COLOR_MENU;
1988   int text_color_key = COLOR_MENUTEXT;
1989   switch (control_state) {
1990     case kDisabled:
1991       bg_color_key = is_selected ? COLOR_HIGHLIGHT : COLOR_MENU;
1992       text_color_key = COLOR_GRAYTEXT;
1993       break;
1994     case kHovered:
1995       bg_color_key = COLOR_HIGHLIGHT;
1996       text_color_key = COLOR_HIGHLIGHTTEXT;
1997       break;
1998     case kNormal:
1999       break;
2000     case kPressed:
2001     case kNumStates:
2002       NOTREACHED();
2003       break;
2004   }
2005   COLORREF old_bg_color = SetBkColor(hdc, GetSysColor(bg_color_key));
2006   COLORREF old_text_color = SetTextColor(hdc, GetSysColor(text_color_key));
2007   BitBlt(hdc, rect.x(), rect.y(), width, height, bitmap_dc, 0, 0, SRCCOPY);
2008   SetBkColor(hdc, old_bg_color);
2009   SetTextColor(hdc, old_text_color);
2010
2011   return S_OK;
2012 }
2013
2014 HANDLE NativeThemeWin::GetThemeHandle(ThemeName theme_name) const {
2015   if (!open_theme_ || theme_name < 0 || theme_name >= LAST)
2016     return 0;
2017
2018   if (theme_handles_[theme_name])
2019     return theme_handles_[theme_name];
2020
2021   // Not found, try to load it.
2022   HANDLE handle = 0;
2023   switch (theme_name) {
2024   case BUTTON:
2025     handle = open_theme_(NULL, L"Button");
2026     break;
2027   case LIST:
2028     handle = open_theme_(NULL, L"Listview");
2029     break;
2030   case MENU:
2031     handle = open_theme_(NULL, L"Menu");
2032     break;
2033   case MENULIST:
2034     handle = open_theme_(NULL, L"Combobox");
2035     break;
2036   case SCROLLBAR:
2037     handle = open_theme_(NULL, L"Scrollbar");
2038     break;
2039   case STATUS:
2040     handle = open_theme_(NULL, L"Status");
2041     break;
2042   case TAB:
2043     handle = open_theme_(NULL, L"Tab");
2044     break;
2045   case TEXTFIELD:
2046     handle = open_theme_(NULL, L"Edit");
2047     break;
2048   case TRACKBAR:
2049     handle = open_theme_(NULL, L"Trackbar");
2050     break;
2051   case WINDOW:
2052     handle = open_theme_(NULL, L"Window");
2053     break;
2054   case PROGRESS:
2055     handle = open_theme_(NULL, L"Progress");
2056     break;
2057   case SPIN:
2058     handle = open_theme_(NULL, L"Spin");
2059     break;
2060   case LAST:
2061     NOTREACHED();
2062     break;
2063   }
2064   theme_handles_[theme_name] = handle;
2065   return handle;
2066 }
2067
2068 }  // namespace ui