Lots of random cleanups, mostly for native_theme_win.cc:

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 <uxtheme.h>
 #include <vsstyle.h>
 #include <vssym32.h>
@@ skipping 114 matching lines @@
   gfx::Rect result(*rect);
   result.Inset(size, size);
   return result.ToRECT();
 }
 
 }  // namespace
 
 namespace ui {
 
 bool NativeThemeWin::IsThemingActive() const {
-  if (is_theme_active_)
-    return !!is_theme_active_();
-  return false;
+  return is_theme_active_ && is_theme_active_();
 }
 
 bool NativeThemeWin::IsUsingHighContrastTheme() const {
   if (is_using_high_contrast_valid_)
     return is_using_high_contrast_;
   HIGHCONTRAST result;
   result.cbSize = sizeof(HIGHCONTRAST);
   is_using_high_contrast_ =
       SystemParametersInfo(SPI_GETHIGHCONTRAST, result.cbSize, &result, 0) &&
       (result.dwFlags & HCF_HIGHCONTRASTON) == HCF_HIGHCONTRASTON;
   is_using_high_contrast_valid_ = true;
   return is_using_high_contrast_;
 }
 
 HRESULT NativeThemeWin::GetThemeColor(ThemeName theme,
                                       int part_id,
                                       int state_id,
                                       int prop_id,
                                       SkColor* color) const {
   HANDLE handle = GetThemeHandle(theme);
-  if (handle && get_theme_color_) {
-    COLORREF color_ref;
-    if (get_theme_color_(handle, part_id, state_id, prop_id, &color_ref) ==
-        S_OK) {
-      *color = skia::COLORREFToSkColor(color_ref);
-      return S_OK;
-    }
-  }
-  return E_NOTIMPL;
+  if (!handle || !get_theme_color_)
+    return E_NOTIMPL;
+  COLORREF color_ref;
+  if (get_theme_color_(handle, part_id, state_id, prop_id, &color_ref) != S_OK)
+    return E_NOTIMPL;
+  *color = skia::COLORREFToSkColor(color_ref);
+  return S_OK;
 }
 
 SkColor NativeThemeWin::GetThemeColorWithDefault(ThemeName theme,
                                                  int part_id,
                                                  int state_id,
                                                  int prop_id,
                                                  int default_sys_color) const {
   SkColor color;
-  if (GetThemeColor(theme, part_id, state_id, prop_id, &color) != S_OK)
-    color = color_utils::GetSysSkColor(default_sys_color);
-  return color;
+  return (GetThemeColor(theme, part_id, state_id, prop_id, &color) == S_OK) ?
+      color : color_utils::GetSysSkColor(default_sys_color);
 }
 
 gfx::Size NativeThemeWin::GetThemeBorderSize(ThemeName theme) const {
   // For simplicity use the wildcard state==0, part==0, since it works
   // for the cases we currently depend on.
   int border;
-  if (GetThemeInt(theme, 0, 0, TMT_BORDERSIZE, &border) == S_OK)
-    return gfx::Size(border, border);
-  else
-    return gfx::Size(GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
+  return (GetThemeInt(theme, 0, 0, TMT_BORDERSIZE, &border) == S_OK) ?
+      gfx::Size(border, border) :
+      gfx::Size(GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
 }
 
 void NativeThemeWin::DisableTheming() const {
-  if (!set_theme_properties_)
-    return;
-  set_theme_properties_(0);
+  if (set_theme_properties_)
+    set_theme_properties_(0);
 }
 
 void NativeThemeWin::CloseHandles() const {
   if (!close_theme_)
     return;
 
   for (int i = 0; i < LAST; ++i) {
     if (theme_handles_[i]) {
       close_theme_(theme_handles_[i]);
       theme_handles_[i] = NULL;
     }
   }
 }
 
 bool NativeThemeWin::IsClassicTheme(ThemeName name) const {
-  if (!theme_dll_)
-    return true;
-
-  return !GetThemeHandle(name);
+  return !theme_dll_ || !GetThemeHandle(name);
 }
 
 // static
 NativeThemeWin* NativeThemeWin::instance() {
   CR_DEFINE_STATIC_LOCAL(NativeThemeWin, s_native_theme, ());
   return &s_native_theme;
 }
 
 gfx::Size NativeThemeWin::GetPartSize(Part part,
                                       State state,
@@ skipping 16 matching lines @@
       int size = gfx::win::GetSystemMetricsInDIP(SM_CXVSCROLL);
       if (size == 0)
         size = 17;
       return gfx::Size(size, size);
     }
   }
 
   int part_id = GetWindowsPart(part, state, extra);
   int state_id = GetWindowsState(part, state, extra);
 
+  base::win::ScopedGetDC screen_dc(NULL);
   SIZE size;
-  HDC hdc = GetDC(NULL);
-  HRESULT hr = GetThemePartSize(GetThemeName(part), hdc, part_id, state_id,
-                                NULL, TS_TRUE, &size);
-  ReleaseDC(NULL, hdc);
+  if (SUCCEEDED(GetThemePartSize(GetThemeName(part), screen_dc, part_id,
+                                 state_id, NULL, TS_TRUE, &size)))
+    return gfx::Size(size.cx, size.cy);
 
-  if (FAILED(hr)) {
-    // TODO(rogerta): For now, we need to support radio buttons and checkboxes
-    // when theming is not enabled.  Support for other parts can be added
-    // if/when needed.
-    switch (part) {
-      case kCheckbox:
-      case kRadio:
-        // TODO(rogerta): I was not able to find any API to get the default
-        // size of these controls, so determined these values empirically.
-        size.cx = 13;
-        size.cy = 13;
-        break;
-      default:
-        size.cx = 0;
-        size.cy = 0;
-        break;
-    }
-  }
-
-  return gfx::Size(size.cx, size.cy);
+  // TODO(rogerta): For now, we need to support radio buttons and checkboxes
+  // when theming is not enabled.  Support for other parts can be added
+  // if/when needed.
+  return (part == kCheckbox || part == kRadio) ?
+      gfx::Size(13, 13) : gfx::Size();
 }
 
 void NativeThemeWin::Paint(SkCanvas* canvas,
                            Part part,
                            State state,
                            const gfx::Rect& rect,
                            const ExtraParams& extra) const {
   if (rect.IsEmpty())
     return;
 
@@ skipping 23 matching lines @@
     // Scrollbar components on Windows Classic theme (on all Windows versions)
     // have particularly problematic alpha values, so always draw them
     // indirectly. In addition, scrollbar thumbs and grippers for the Windows XP
     // theme (available only on Windows XP) also need their alpha values
     // fixed.
     switch (part) {
       case kScrollbarDownArrow:
       case kScrollbarUpArrow:
       case kScrollbarLeftArrow:
       case kScrollbarRightArrow:
-        if (!GetThemeHandle(SCROLLBAR))
-          needs_paint_indirect = true;
+        needs_paint_indirect = !GetThemeHandle(SCROLLBAR);
         break;
       case kScrollbarHorizontalThumb:
       case kScrollbarVerticalThumb:
       case kScrollbarHorizontalGripper:
       case kScrollbarVerticalGripper:
-        if (!GetThemeHandle(SCROLLBAR) ||
-            base::win::GetVersion() == base::win::VERSION_XP)
-          needs_paint_indirect = true;
-        break;
-      default:
+        needs_paint_indirect = !GetThemeHandle(SCROLLBAR) ||
+            base::win::GetVersion() == base::win::VERSION_XP;
         break;
     }
   }
 
   if (needs_paint_indirect)
     PaintIndirect(canvas, part, state, rect, extra);
   else
     PaintDirect(canvas, part, state, rect, extra);
 }
 
@@ skipping 66 matching lines @@
                                  Part part,
                                  State state,
                                  const gfx::Rect& rect,
                                  const ExtraParams& extra) const {
   skia::ScopedPlatformPaint scoped_platform_paint(canvas);
   HDC hdc = scoped_platform_paint.GetPlatformSurface();
 
   switch (part) {
     case kCheckbox:
       PaintCheckbox(hdc, part, state, rect, extra.button);
-      break;
+      return;
     case kRadio:
       PaintRadioButton(hdc, part, state, rect, extra.button);
-      break;
+      return;
     case kPushButton:
       PaintPushButton(hdc, part, state, rect, extra.button);
-      break;
+      return;
     case kMenuPopupArrow:
       PaintMenuArrow(hdc, state, rect, extra.menu_arrow);
-      break;
+      return;
     case kMenuPopupGutter:
       PaintMenuGutter(hdc, rect);
-      break;
+      return;
     case kMenuPopupSeparator:
       PaintMenuSeparator(hdc, rect, extra.menu_separator);
-      break;
+      return;
     case kMenuPopupBackground:
       PaintMenuBackground(hdc, rect);
-      break;
+      return;
     case kMenuCheck:
       PaintMenuCheck(hdc, state, rect, extra.menu_check);
-      break;
+      return;
     case kMenuCheckBackground:
       PaintMenuCheckBackground(hdc, state, rect);
-      break;
+      return;
     case kMenuItemBackground:
       PaintMenuItemBackground(hdc, state, rect, extra.menu_item);
-      break;
+      return;
     case kMenuList:
       PaintMenuList(hdc, state, rect, extra.menu_list);
-      break;
+      return;
     case kScrollbarDownArrow:
     case kScrollbarUpArrow:
     case kScrollbarLeftArrow:
     case kScrollbarRightArrow:
       PaintScrollbarArrow(hdc, part, state, rect, extra.scrollbar_arrow);
-      break;
+      return;
     case kScrollbarHorizontalTrack:
     case kScrollbarVerticalTrack:
       PaintScrollbarTrack(canvas, hdc, part, state, rect,
                           extra.scrollbar_track);
-      break;
+      return;
     case kScrollbarCorner:
       canvas->drawColor(SK_ColorWHITE, SkXfermode::kSrc_Mode);
-      break;
+      return;
     case kScrollbarHorizontalThumb:
     case kScrollbarVerticalThumb:
     case kScrollbarHorizontalGripper:
     case kScrollbarVerticalGripper:
       PaintScrollbarThumb(hdc, part, state, rect, extra.scrollbar_thumb);
-      break;
+      return;
     case kInnerSpinButton:
       PaintSpinButton(hdc, part, state, rect, extra.inner_spin);
-      break;
+      return;
     case kTrackbarThumb:
     case kTrackbarTrack:
       PaintTrackbar(canvas, hdc, part, state, rect, extra.trackbar);
-      break;
+      return;
     case kProgressBar:
       PaintProgressBar(hdc, rect, extra.progress_bar);
-      break;
+      return;
     case kWindowResizeGripper:
       PaintWindowResizeGripper(hdc, rect);
-      break;
+      return;
     case kTabPanelBackground:
       PaintTabPanelBackground(hdc, rect);
-      break;
+      return;
     case kTextField:
       PaintTextField(hdc, part, state, rect, extra.text_field);
-      break;
+      return;
 
     case kSliderTrack:
     case kSliderThumb:
     default:
-      // While transitioning NativeThemeWin to the single Paint() entry point,
-      // unsupported parts will DCHECK here.
       NOTREACHED();
+      return;
   }
 }
 
 SkColor NativeThemeWin::GetSystemColor(ColorId color_id) const {
   SkColor color;
   if (CommonThemeGetSystemColor(color_id, &color))
     return color;
 
   switch (color_id) {
     // Windows
     case kColorId_WindowBackground:
       return system_colors_[COLOR_WINDOW];
 
     // Dialogs
     case kColorId_DialogBackground:
-      if (gfx::IsInvertedColorScheme())
-        return color_utils::InvertColor(kDialogBackgroundColor);
-      return kDialogBackgroundColor;
+      return gfx::IsInvertedColorScheme() ?
+          color_utils::InvertColor(kDialogBackgroundColor) :
+          kDialogBackgroundColor;
 
     // FocusableBorder
     case kColorId_FocusedBorderColor:
       return kFocusedBorderColor;
     case kColorId_UnfocusedBorderColor:
       return kUnfocusedBorderColor;
 
     // Button
     case kColorId_ButtonBackgroundColor:
       return kButtonBackgroundColor;
@@ skipping 116 matching lines @@
     case kColorId_ResultsTableHoveredDivider:
       return color_utils::AlphaBlend(
           system_colors_[COLOR_WINDOWTEXT],
           GetSystemColor(kColorId_ResultsTableHoveredBackground), 0x34);
     case kColorId_ResultsTableSelectedDivider:
       return color_utils::AlphaBlend(system_colors_[COLOR_HIGHLIGHTTEXT],
                                      system_colors_[COLOR_HIGHLIGHT], 0x34);
 
     default:
       NOTREACHED();
-      break;
+      return kInvalidColorIdColor;
   }
-  return kInvalidColorIdColor;
 }
 
 void NativeThemeWin::PaintIndirect(SkCanvas* 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.
 
   // Create an offscreen canvas that is backed by an HDC.
   skia::RefPtr<skia::BitmapPlatformDevice> device = skia::AdoptRef(
       skia::BitmapPlatformDevice::Create(
           rect.width(), rect.height(), false, NULL));
   DCHECK(device);
-  if (!device)
-    return;
   SkCanvas offscreen_canvas(device.get());
   DCHECK(skia::SupportsPlatformPaint(&offscreen_canvas));
 
   // Some of the Windows theme drawing operations do not write correct alpha
   // values for fully-opaque pixels; instead the pixels get alpha 0. This is
   // especially a problem on Windows XP or when using the Classic theme.
   //
   // To work-around this, mark all pixels with a placeholder value, to detect
   // which pixels get touched by the paint operation. After paint, set any
   // pixels that have alpha 0 to opaque and placeholders to fully-transparent.
   const SkColor placeholder = SkColorSetARGB(1, 0, 0, 0);
   offscreen_canvas.clear(placeholder);
 
   // Offset destination rects to have origin (0,0).
   gfx::Rect adjusted_rect(rect.size());
   ExtraParams adjusted_extra(extra);
   switch (part) {
     case kProgressBar:
       adjusted_extra.progress_bar.value_rect_x = 0;
       adjusted_extra.progress_bar.value_rect_y = 0;
       break;
     case kScrollbarHorizontalTrack:
     case kScrollbarVerticalTrack:
       adjusted_extra.scrollbar_track.track_x = 0;
       adjusted_extra.scrollbar_track.track_y = 0;
       break;
-    default: break;
   }
   // Draw the theme controls using existing HDC-drawing code.
-  PaintDirect(&offscreen_canvas,
-              part,
-              state,
-              adjusted_rect,
-              adjusted_extra);
+  PaintDirect(&offscreen_canvas, part, state, adjusted_rect, adjusted_extra);
 
   // Copy the pixels to a bitmap that has ref-counted pixel storage, which is
   // necessary to have when drawing to a SkPicture.
   const SkBitmap& hdc_bitmap =
       offscreen_canvas.getDevice()->accessBitmap(false);
   SkBitmap bitmap;
   hdc_bitmap.copyTo(&bitmap, kN32_SkColorType);
 
   // Post-process the pixels to fix up the alpha values (see big comment above).
   const SkPMColor placeholder_value = SkPreMultiplyColor(placeholder);
@@ skipping 17 matching lines @@
 }
 
 HRESULT NativeThemeWin::GetThemePartSize(ThemeName theme_name,
                                          HDC hdc,
                                          int part_id,
                                          int state_id,
                                          RECT* rect,
                                          int ts,
                                          SIZE* size) const {
   HANDLE handle = GetThemeHandle(theme_name);
-  if (handle && get_theme_part_size_)
-    return get_theme_part_size_(handle, hdc, part_id, state_id, rect, ts, size);
-
-  return E_NOTIMPL;
+  return (handle && get_theme_part_size_) ?
+      get_theme_part_size_(handle, hdc, part_id, state_id, rect, ts, size) :
+      E_NOTIMPL;
 }
 
 HRESULT NativeThemeWin::PaintButton(HDC hdc,
                                     State state,
                                     const ButtonExtraParams& extra,
                                     int part_id,
                                     int state_id,
                                     RECT* rect) const {
   HANDLE handle = GetThemeHandle(BUTTON);
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, part_id, state_id, rect, NULL);
 
   // Adjust classic_state based on part, state, and extras.
   int classic_state = extra.classic_state;
   switch (part_id) {
     case BP_CHECKBOX:
       classic_state |= DFCS_BUTTONCHECK;
       break;
     case BP_RADIOBUTTON:
       classic_state |= DFCS_BUTTONRADIO;
       break;
     case BP_PUSHBUTTON:
       classic_state |= DFCS_BUTTONPUSH;
       break;
     default:
-      NOTREACHED() << "Unknown part_id: " << part_id;
+      NOTREACHED();
       break;
   }
 
-  switch (state) {
-    case kDisabled:
-      classic_state |= DFCS_INACTIVE;
-      break;
-    case kPressed:
-      classic_state |= DFCS_PUSHED;
-      break;
-    case kNormal:
-    case kHovered:
-      break;
-    default:
-      NOTREACHED() << "Unknown state: " << state;
-      break;
-  }
+  if (state == kDisabled)
+    classic_state |= DFCS_INACTIVE;
+  else if (state == kPressed)
+    classic_state |= DFCS_PUSHED;
 
   if (extra.checked)
     classic_state |= DFCS_CHECKED;
 
   // Draw it manually.
   // All pressed states have both low bits set, and no other states do.
   const bool focused = ((state_id & ETS_FOCUSED) == ETS_FOCUSED);
   const bool pressed = ((state_id & PBS_PRESSED) == PBS_PRESSED);
   if ((BP_PUSHBUTTON == part_id) && (pressed || focused)) {
     // BP_PUSHBUTTON has a focus rect drawn around the outer edge, and the
@@ skipping 50 matching lines @@
   }
 
   DrawEdge(hdc, &rect_win, EDGE_ETCHED, BF_TOP);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintMenuGutter(HDC hdc,
                                         const gfx::Rect& rect) const {
   RECT rect_win = rect.ToRECT();
   HANDLE handle = GetThemeHandle(MENU);
-  if (handle && draw_theme_)
-    return draw_theme_(handle, hdc, MENU_POPUPGUTTER, MPI_NORMAL, &rect_win,
-                       NULL);
-  return E_NOTIMPL;
+  return (handle && draw_theme_) ?
+      draw_theme_(handle, hdc, MENU_POPUPGUTTER, MPI_NORMAL, &rect_win, NULL) :
+      E_NOTIMPL;
 }
 
-HRESULT NativeThemeWin::PaintMenuArrow(HDC hdc,
-                                       State state,
-                                       const gfx::Rect& rect,
-                                       const MenuArrowExtraParams& extra)
-    const {
+HRESULT NativeThemeWin::PaintMenuArrow(
+    HDC hdc,
+    State state,
+    const gfx::Rect& rect,
+    const MenuArrowExtraParams& extra) const {
   int state_id = MSM_NORMAL;
   if (state == kDisabled)
     state_id = MSM_DISABLED;
 
   HANDLE handle = GetThemeHandle(MENU);
   RECT rect_win = rect.ToRECT();
   if (handle && draw_theme_) {
     if (extra.pointing_right) {
       return draw_theme_(handle, hdc, MENU_POPUPSUBMENU, state_id, &rect_win,
                          NULL);
-    } else {
-      // There is no way to tell the uxtheme API to draw a left pointing arrow;
-      // it doesn't have a flag equivalent to DFCS_MENUARROWRIGHT.  But they
-      // are needed for RTL locales on Vista.  So use a memory DC and mirror
-      // the region with GDI's StretchBlt.
-      gfx::Rect r(rect);
-      base::win::ScopedCreateDC mem_dc(CreateCompatibleDC(hdc));
-      base::win::ScopedBitmap mem_bitmap(CreateCompatibleBitmap(hdc, r.width(),
-                                                                r.height()));
-      base::win::ScopedSelectObject select_bitmap(mem_dc, mem_bitmap);
-      // Copy and horizontally mirror the background from hdc into mem_dc. Use
-      // a negative-width source rect, starting at the rightmost pixel.
-      StretchBlt(mem_dc, 0, 0, r.width(), r.height(),
-                 hdc, r.right()-1, r.y(), -r.width(), r.height(), SRCCOPY);
-      // Draw the arrow.
-      RECT theme_rect = {0, 0, r.width(), r.height()};
-      HRESULT result = draw_theme_(handle, mem_dc, MENU_POPUPSUBMENU,
-                                   state_id, &theme_rect, NULL);
-      // Copy and mirror the result back into mem_dc.
-      StretchBlt(hdc, r.x(), r.y(), r.width(), r.height(),
-                 mem_dc, r.width()-1, 0, -r.width(), r.height(), SRCCOPY);
-      return result;
     }
+    // There is no way to tell the uxtheme API to draw a left pointing arrow; it
+    // doesn't have a flag equivalent to DFCS_MENUARROWRIGHT.  But they are
+    // needed for RTL locales on Vista.  So use a memory DC and mirror the
+    // region with GDI's StretchBlt.
+    gfx::Rect r(rect);
+    base::win::ScopedCreateDC mem_dc(CreateCompatibleDC(hdc));
+    base::win::ScopedBitmap mem_bitmap(CreateCompatibleBitmap(hdc, r.width(),
+                                                              r.height()));
+    base::win::ScopedSelectObject select_bitmap(mem_dc, mem_bitmap);
+    // Copy and horizontally mirror the background from hdc into mem_dc. Use
+    // a negative-width source rect, starting at the rightmost pixel.
+    StretchBlt(mem_dc, 0, 0, r.width(), r.height(),
+                hdc, r.right()-1, r.y(), -r.width(), r.height(), SRCCOPY);
+    // Draw the arrow.
+    RECT theme_rect = {0, 0, r.width(), r.height()};
+    HRESULT result = draw_theme_(handle, mem_dc, MENU_POPUPSUBMENU,
+                                  state_id, &theme_rect, NULL);
+    // Copy and mirror the result back into mem_dc.
+    StretchBlt(hdc, r.x(), r.y(), r.width(), r.height(),
+                mem_dc, r.width()-1, 0, -r.width(), r.height(), SRCCOPY);
+    return result;
   }
 
   // For some reason, Windows uses the name DFCS_MENUARROWRIGHT to indicate a
-  // left pointing arrow. This makes the following 'if' statement slightly
-  // counterintuitive.
-  UINT pfc_state;
-  if (extra.pointing_right)
-    pfc_state = DFCS_MENUARROW;
-  else
-    pfc_state = DFCS_MENUARROWRIGHT;
+  // left pointing arrow. This makes the following statement counterintuitive.
+  UINT pfc_state = extra.pointing_right ? DFCS_MENUARROW : DFCS_MENUARROWRIGHT;
   return PaintFrameControl(hdc, rect, DFC_MENU, pfc_state, extra.is_selected,
                            state);
 }
 
 HRESULT NativeThemeWin::PaintMenuBackground(HDC hdc,
                                             const gfx::Rect& rect) const {
   HANDLE handle = GetThemeHandle(MENU);
   RECT rect_win = rect.ToRECT();
   if (handle && draw_theme_) {
     HRESULT result = draw_theme_(handle, hdc, MENU_POPUPBACKGROUND, 0,
                                  &rect_win, NULL);
     FrameRect(hdc, &rect_win, GetSysColorBrush(COLOR_3DSHADOW));
     return result;
   }
 
   FillRect(hdc, &rect_win, GetSysColorBrush(COLOR_MENU));
   DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintMenuCheck(
     HDC hdc,
     State state,
     const gfx::Rect& rect,
     const MenuCheckExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(MENU);
-  int state_id;
-  if (extra.is_radio) {
-    state_id = state == kDisabled ? MC_BULLETDISABLED : MC_BULLETNORMAL;
-  } else {
-    state_id = state == kDisabled ? MC_CHECKMARKDISABLED : MC_CHECKMARKNORMAL;
+  if (handle && draw_theme_) {
+    const int state_id = extra.is_radio ?
+        ((state == kDisabled) ? MC_BULLETDISABLED : MC_BULLETNORMAL) :
+        ((state == kDisabled) ? MC_CHECKMARKDISABLED : MC_CHECKMARKNORMAL);

[Peter Kasting, 2014/07/09 20:31:01]

I usually try to avoid nested ternaries, but in this case it actually looked
clearer to me (and this file already was nesting them in one or two cases, so
there was some precedent)

+    RECT rect_win = rect.ToRECT();
+    return draw_theme_(handle, hdc, MENU_POPUPCHECK, state_id, &rect_win, NULL);
   }
 
-  RECT rect_win = rect.ToRECT();
-  if (handle && draw_theme_)
-    return draw_theme_(handle, hdc, MENU_POPUPCHECK, state_id, &rect_win, NULL);
-
   return PaintFrameControl(hdc, rect, DFC_MENU,
                            extra.is_radio ? DFCS_MENUBULLET : DFCS_MENUCHECK,
                            extra.is_selected, state);
 }
 
 HRESULT NativeThemeWin::PaintMenuCheckBackground(HDC hdc,
                                                  State state,
                                                  const gfx::Rect& rect) const {
   HANDLE handle = GetThemeHandle(MENU);
+  if (!handle || !draw_theme_)
+    return S_OK;  // Nothing to do for background.
+
   int state_id = state == kDisabled ? MCB_DISABLED : MCB_NORMAL;
   RECT rect_win = rect.ToRECT();
-  if (handle && draw_theme_)
-    return draw_theme_(handle, hdc, MENU_POPUPCHECKBACKGROUND, state_id,
-                       &rect_win, NULL);
-  // Nothing to do for background.
-  return S_OK;
+  return draw_theme_(handle, hdc, MENU_POPUPCHECKBACKGROUND, state_id,
+                     &rect_win, NULL);
 }
 
 HRESULT NativeThemeWin::PaintMenuItemBackground(
     HDC hdc,
     State state,
     const gfx::Rect& rect,
     const MenuItemExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(MENU);
   RECT rect_win = rect.ToRECT();
   int state_id;
   switch (state) {
-    case kNormal:
-      state_id = MPI_NORMAL;
-      break;
     case kDisabled:
       state_id = extra.is_selected ? MPI_DISABLEDHOT : MPI_DISABLED;
       break;
     case kHovered:
       state_id = MPI_HOT;
       break;
+    case kNormal:
+      state_id = MPI_NORMAL;
+      break;
     default:
-      NOTREACHED() << "Invalid state " << state;
+      NOTREACHED();
       break;
   }
 
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, MENU_POPUPITEM, state_id, &rect_win, NULL);
 
   if (extra.is_selected)
     FillRect(hdc, &rect_win, GetSysColorBrush(COLOR_HIGHLIGHT));
   return S_OK;
 }
@@ skipping 11 matching lines @@
     case kHovered:
       state_id = PBS_HOT;
       break;
     case kNormal:
       state_id = extra.is_default ? PBS_DEFAULTED : PBS_NORMAL;
       break;
     case kPressed:
       state_id = PBS_PRESSED;
       break;
     default:
-      NOTREACHED() << "Invalid state: " << state;
+      NOTREACHED();
       break;
   }
 
   RECT rect_win = rect.ToRECT();
   return PaintButton(hdc, state, extra, BP_PUSHBUTTON, state_id, &rect_win);
 }
 
 HRESULT NativeThemeWin::PaintRadioButton(HDC hdc,
                                          Part part,
                                          State state,
                                          const gfx::Rect& rect,
                                          const ButtonExtraParams& extra) const {
   int state_id;
   switch (state) {
     case kDisabled:
       state_id = extra.checked ? RBS_CHECKEDDISABLED : RBS_UNCHECKEDDISABLED;
       break;
     case kHovered:
       state_id = extra.checked ? RBS_CHECKEDHOT : RBS_UNCHECKEDHOT;
       break;
     case kNormal:
       state_id = extra.checked ? RBS_CHECKEDNORMAL : RBS_UNCHECKEDNORMAL;
       break;
     case kPressed:
       state_id = extra.checked ? RBS_CHECKEDPRESSED : RBS_UNCHECKEDPRESSED;
       break;
     default:
-      NOTREACHED() << "Invalid state: " << state;
+      NOTREACHED();
       break;
   }
 
   RECT rect_win = rect.ToRECT();
   return PaintButton(hdc, state, extra, BP_RADIOBUTTON, state_id, &rect_win);
 }
 
 HRESULT NativeThemeWin::PaintCheckbox(HDC hdc,
                                       Part part,
                                       State state,
                                       const gfx::Rect& rect,
                                       const ButtonExtraParams& extra) const {
   int state_id;
   switch (state) {
     case kDisabled:
-      state_id = extra.checked ? CBS_CHECKEDDISABLED :
-          extra.indeterminate ? CBS_MIXEDDISABLED :
-              CBS_UNCHECKEDDISABLED;
+      state_id = extra.checked ?
+          CBS_CHECKEDDISABLED :
+          (extra.indeterminate ? CBS_MIXEDDISABLED : CBS_UNCHECKEDDISABLED);
       break;
     case kHovered:
-      state_id = extra.checked ? CBS_CHECKEDHOT :
-          extra.indeterminate ? CBS_MIXEDHOT :
-              CBS_UNCHECKEDHOT;
+      state_id = extra.checked ?
+          CBS_CHECKEDHOT :
+          (extra.indeterminate ? CBS_MIXEDHOT : CBS_UNCHECKEDHOT);
       break;
     case kNormal:
-      state_id = extra.checked ? CBS_CHECKEDNORMAL :
-          extra.indeterminate ? CBS_MIXEDNORMAL :
-              CBS_UNCHECKEDNORMAL;
+      state_id = extra.checked ?
+          CBS_CHECKEDNORMAL :
+          (extra.indeterminate ? CBS_MIXEDNORMAL : CBS_UNCHECKEDNORMAL);
       break;
     case kPressed:
-      state_id = extra.checked ? CBS_CHECKEDPRESSED :
-          extra.indeterminate ? CBS_MIXEDPRESSED :
-              CBS_UNCHECKEDPRESSED;
+      state_id = extra.checked ?
+          CBS_CHECKEDPRESSED :
+          (extra.indeterminate ? CBS_MIXEDPRESSED : CBS_UNCHECKEDPRESSED);
       break;
     default:
-      NOTREACHED() << "Invalid state: " << state;
+      NOTREACHED();
       break;
   }
 
   RECT rect_win = rect.ToRECT();
   return PaintButton(hdc, state, extra, BP_CHECKBOX, state_id, &rect_win);
 }
 
 HRESULT NativeThemeWin::PaintMenuList(HDC hdc,
                                       State state,
                                       const gfx::Rect& rect,
                                       const MenuListExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(MENULIST);
   RECT rect_win = rect.ToRECT();
   int state_id;
   switch (state) {
-    case kNormal:
-      state_id = CBXS_NORMAL;
-      break;
     case kDisabled:
       state_id = CBXS_DISABLED;
       break;
     case kHovered:
       state_id = CBXS_HOT;
       break;
+    case kNormal:
+      state_id = CBXS_NORMAL;
+      break;
     case kPressed:
       state_id = CBXS_PRESSED;
       break;
     default:
-      NOTREACHED() << "Invalid state " << state;
+      NOTREACHED();
       break;
   }
 
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, CP_DROPDOWNBUTTON, state_id, &rect_win,
                        NULL);
 
   // Draw it manually.
   DrawFrameControl(hdc, &rect_win, DFC_SCROLL,
                    DFCS_SCROLLCOMBOBOX | extra.classic_state);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintScrollbarArrow(
     HDC hdc,
     Part part,
     State state,
     const gfx::Rect& rect,
     const ScrollbarArrowExtraParams& extra) const {
-  static const int state_id_matrix[4][kMaxState] = {
+  static const int state_id_matrix[4][kNumStates] = {
       ABS_DOWNDISABLED, ABS_DOWNHOT, ABS_DOWNNORMAL, ABS_DOWNPRESSED,
       ABS_LEFTDISABLED, ABS_LEFTHOT, ABS_LEFTNORMAL, ABS_LEFTPRESSED,
       ABS_RIGHTDISABLED, ABS_RIGHTHOT, ABS_RIGHTNORMAL, ABS_RIGHTPRESSED,
       ABS_UPDISABLED, ABS_UPHOT, ABS_UPNORMAL, ABS_UPPRESSED
   };
   HANDLE handle = GetThemeHandle(SCROLLBAR);
   RECT rect_win = rect.ToRECT();
   if (handle && draw_theme_) {
     int index = part - kScrollbarDownArrow;
-    DCHECK(index >=0 && index < 4);
+    DCHECK_GE(index, 0);
+    DCHECK_LT(static_cast<size_t>(index), arraysize(state_id_matrix));
     int state_id = state_id_matrix[index][state];
 
     // Hovering means that the cursor is over the scroolbar, but not over the
     // specific arrow itself.  We don't want to show it "hot" mode, but only
     // in "hover" mode.
     if (state == kHovered && extra.is_hovering) {
       switch (part) {
         case kScrollbarDownArrow:
           state_id = ABS_DOWNHOVER;
           break;
         case kScrollbarLeftArrow:
           state_id = ABS_LEFTHOVER;
           break;
         case kScrollbarRightArrow:
           state_id = ABS_RIGHTHOVER;
           break;
         case kScrollbarUpArrow:
           state_id = ABS_UPHOVER;
           break;
         default:
-          NOTREACHED() << "Invalid part: " << part;
+          NOTREACHED();
           break;
       }
     }
     return PaintScaledTheme(handle, hdc, SBP_ARROWBTN, state_id, rect);
   }
 
   int classic_state = DFCS_SCROLLDOWN;
   switch (part) {
     case kScrollbarDownArrow:
       classic_state = DFCS_SCROLLDOWN;
       break;
     case kScrollbarLeftArrow:
       classic_state = DFCS_SCROLLLEFT;
       break;
     case kScrollbarRightArrow:
       classic_state = DFCS_SCROLLRIGHT;
       break;
     case kScrollbarUpArrow:
       classic_state = DFCS_SCROLLUP;
       break;
     default:
-      NOTREACHED() << "Invalid part: " << part;
+      NOTREACHED();
       break;
   }
-  switch (state) {
-    case kDisabled:
-      classic_state |= DFCS_INACTIVE;
-      break;
-    case kHovered:
-      classic_state |= DFCS_HOT;
-      break;
-    case kNormal:
-      break;
-    case kPressed:
-      classic_state |= DFCS_PUSHED;
-      break;
-    default:
-      NOTREACHED() << "Invalid state: " << state;
-      break;
-  }
+  if (state == kDisabled)
+    classic_state |= DFCS_INACTIVE;
+  else if (state == kHovered)
+    classic_state |= DFCS_HOT;
+  else if (state == kPressed)
+    classic_state |= DFCS_PUSHED;
   DrawFrameControl(hdc, &rect_win, DFC_SCROLL, classic_state);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintScrollbarThumb(
     HDC hdc,
     Part part,
     State state,
     const gfx::Rect& rect,
     const ScrollbarThumbExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(SCROLLBAR);
   RECT rect_win = rect.ToRECT();
+
   int part_id;
-  int state_id;
-
   switch (part) {
     case NativeTheme::kScrollbarHorizontalThumb:
       part_id = SBP_THUMBBTNHORZ;
       break;
     case NativeTheme::kScrollbarVerticalThumb:
       part_id = SBP_THUMBBTNVERT;
       break;
     case NativeTheme::kScrollbarHorizontalGripper:
       part_id = SBP_GRIPPERHORZ;
       break;
     case NativeTheme::kScrollbarVerticalGripper:
       part_id = SBP_GRIPPERVERT;
       break;
     default:
-      NOTREACHED() << "Invalid part: " << part;
+      NOTREACHED();
       break;
   }
 
+  int state_id;
   switch (state) {
     case kDisabled:
       state_id = SCRBS_DISABLED;
       break;
     case kHovered:
       state_id = extra.is_hovering ? SCRBS_HOVER : SCRBS_HOT;
       break;
     case kNormal:
       state_id = SCRBS_NORMAL;
       break;
     case kPressed:
       state_id = SCRBS_PRESSED;
       break;
     default:
-      NOTREACHED() << "Invalid state: " << state;
+      NOTREACHED();
       break;
   }
 
   if (handle && draw_theme_)
     return PaintScaledTheme(handle, hdc, part_id, state_id, rect);
 
   // Draw it manually.
   if ((part_id == SBP_THUMBBTNHORZ) || (part_id == SBP_THUMBBTNVERT))
     DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT | BF_MIDDLE);
   // Classic mode doesn't have a gripper.
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintScrollbarTrack(
     SkCanvas* canvas,
     HDC hdc,
     Part part,
     State state,
     const gfx::Rect& rect,
     const ScrollbarTrackExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(SCROLLBAR);
   RECT rect_win = rect.ToRECT();
+
   int part_id;
-  int state_id;
-
   switch (part) {
     case NativeTheme::kScrollbarHorizontalTrack:
       part_id = extra.is_upper ? SBP_UPPERTRACKHORZ : SBP_LOWERTRACKHORZ;
       break;
     case NativeTheme::kScrollbarVerticalTrack:
       part_id = extra.is_upper ? SBP_UPPERTRACKVERT : SBP_LOWERTRACKVERT;
       break;
     default:
-      NOTREACHED() << "Invalid part: " << part;
+      NOTREACHED();
       break;
   }
 
+  int state_id;
   switch (state) {
     case kDisabled:
       state_id = SCRBS_DISABLED;
       break;
     case kHovered:
       state_id = SCRBS_HOVER;
       break;
     case kNormal:
       state_id = SCRBS_NORMAL;
       break;
     case kPressed:
       state_id = SCRBS_PRESSED;
       break;
     default:
-      NOTREACHED() << "Invalid state: " << state;
+      NOTREACHED();
       break;
   }
 
   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));
@@ skipping 26 matching lines @@
     case kHovered:
       state_id = extra.spin_up ? UPS_HOT : DNS_HOT;
       break;
     case kNormal:
       state_id = extra.spin_up ? UPS_NORMAL : DNS_NORMAL;
       break;
     case kPressed:
       state_id = extra.spin_up ? UPS_PRESSED : DNS_PRESSED;
       break;
     default:
-      NOTREACHED() << "Invalid state " << state;
+      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 {
-  int part_id = part == kTrackbarTrack ? TKP_TRACK : TKP_THUMBBOTTOM;
-  if (extra.vertical)
-    part_id = part == kTrackbarTrack ? TKP_TRACKVERT : TKP_THUMBVERT;
+  const int part_id = extra.vertical ?
+      ((part == kTrackbarTrack) ? TKP_TRACKVERT : TKP_THUMBVERT) :
+      ((part == kTrackbarTrack) ? TKP_TRACK : TKP_THUMBBOTTOM);
 
   int state_id = 0;
   switch (state) {
     case kDisabled:
       state_id = TUS_DISABLED;
       break;
     case kHovered:
       state_id = TUS_HOT;
       break;
     case kNormal:
       state_id = TUS_NORMAL;
       break;
     case kPressed:
       state_id = TUS_PRESSED;
       break;
     default:
-      NOTREACHED() << "Invalid state " << state;
+      NOTREACHED();
       break;
   }
 
   // Make the channel be 4 px thick in the center of the supplied rect.  (4 px
   // matches what XP does in various menus; GetThemePartSize() doesn't seem to
   // return good values here.)
   RECT rect_win = rect.ToRECT();
   RECT channel_rect = rect.ToRECT();
   const int channel_thickness = 4;
   if (part_id == TKP_TRACK) {
@@ skipping 67 matching lines @@
   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
   // size of moving overlay of the indeterminate progress bar.
   // So we just observed real-world programs and guessed following parameters.
-  const int kDeteminateOverlayPixelsPerSecond = 300;
-  const int kDeteminateOverlayWidth = 120;
+  const int kDeterminateOverlayPixelsPerSecond = 300;
+  const int kDeterminateOverlayWidth = 120;
   const int kIndeterminateOverlayPixelsPerSecond =  175;
   const int kVistaIndeterminateOverlayWidth = 120;
   const int kXPIndeterminateOverlayWidth = 55;
   // The thickness of the bar frame inside |value_rect|
   const int kXPBarPadding = 3;
 
   RECT bar_rect = rect.ToRECT();
   RECT value_rect = gfx::Rect(extra.value_rect_x,
                               extra.value_rect_y,
                               extra.value_rect_width,
                               extra.value_rect_height).ToRECT();
 
-  bool pre_vista = base::win::GetVersion() < base::win::VERSION_VISTA;
   HANDLE handle = GetThemeHandle(PROGRESS);
-  if (handle && draw_theme_ && draw_theme_ex_) {
-    draw_theme_(handle, hdc, PP_BAR, 0, &bar_rect, NULL);
-
-    int bar_width = bar_rect.right - bar_rect.left;
-    if (extra.determinate) {
-      // TODO(morrita): this RTL guess can be wrong.
-      // We should pass the direction from WebKit side.
-      bool is_rtl = (bar_rect.right == value_rect.right &&
-                     bar_rect.left != value_rect.left);
-      // We should care the direction here because PP_CNUNK painting
-      // is asymmetric.
-      DTBGOPTS value_draw_options;
-      value_draw_options.dwSize = sizeof(DTBGOPTS);
-      value_draw_options.dwFlags = is_rtl ? DTBG_MIRRORDC : 0;
-      value_draw_options.rcClip = bar_rect;
-
-      if (pre_vista) {
-        // On XP, progress bar is chunk-style and has no glossy effect.
-        // We need to shrink destination rect to fit the part inside the bar
-        // with an appropriate margin.
-        RECT shrunk_value_rect = InsetRect(&value_rect, kXPBarPadding);
-        draw_theme_ex_(handle, hdc, PP_CHUNK, 0,
-                       &shrunk_value_rect, &value_draw_options);
-      } else  {
-        // On Vista or later, the progress bar part has a
-        // single-block value part. It also has glossy effect.
-        // And the value part has exactly same height as the bar part
-        // so we don't need to shrink the rect.
-        draw_theme_ex_(handle, hdc, PP_FILL, 0,
-                       &value_rect, &value_draw_options);
-
-        int dx = ComputeAnimationProgress(bar_width,
-                                          kDeteminateOverlayWidth,
-                                          kDeteminateOverlayPixelsPerSecond,
-                                          extra.animated_seconds);
-        RECT overlay_rect = value_rect;
-        overlay_rect.left += dx;
-        overlay_rect.right = overlay_rect.left + kDeteminateOverlayWidth;
-        draw_theme_(handle, hdc, PP_MOVEOVERLAY, 0, &overlay_rect, &value_rect);
-      }
-    } else {
-      // A glossy overlay for indeterminate progress bar has small pause
-      // after each animation. We emulate this by adding an invisible margin
-      // the animation has to traverse.
-      int width_with_margin = bar_width + kIndeterminateOverlayPixelsPerSecond;
-      int overlay_width = pre_vista ?
-          kXPIndeterminateOverlayWidth : kVistaIndeterminateOverlayWidth;
-      int dx = ComputeAnimationProgress(width_with_margin,
-                                        overlay_width,
-                                        kIndeterminateOverlayPixelsPerSecond,
-                                        extra.animated_seconds);
-      RECT overlay_rect = bar_rect;
-      overlay_rect.left += dx;
-      overlay_rect.right = overlay_rect.left + overlay_width;
-      if (pre_vista) {
-        RECT shrunk_rect = InsetRect(&overlay_rect, kXPBarPadding);
-        RECT shrunk_bar_rect = InsetRect(&bar_rect, kXPBarPadding);
-        draw_theme_(handle, hdc, PP_CHUNK, 0, &shrunk_rect, &shrunk_bar_rect);
-      } else {
-        draw_theme_(handle, hdc, PP_MOVEOVERLAY, 0, &overlay_rect, &bar_rect);
-      }
-    }
-
+  if (!handle || !draw_theme_ || !draw_theme_ex_) {
+    FillRect(hdc, &bar_rect, GetSysColorBrush(COLOR_BTNFACE));
+    FillRect(hdc, &value_rect, GetSysColorBrush(COLOR_BTNSHADOW));
+    DrawEdge(hdc, &bar_rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
     return S_OK;
   }
 
-  HBRUSH bg_brush = GetSysColorBrush(COLOR_BTNFACE);
-  HBRUSH fg_brush = GetSysColorBrush(COLOR_BTNSHADOW);
-  FillRect(hdc, &bar_rect, bg_brush);
-  FillRect(hdc, &value_rect, fg_brush);
-  DrawEdge(hdc, &bar_rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
+  draw_theme_(handle, hdc, PP_BAR, 0, &bar_rect, NULL);
+
+  bool pre_vista = base::win::GetVersion() < base::win::VERSION_VISTA;
+  int bar_width = bar_rect.right - bar_rect.left;
+  if (!extra.determinate) {
+    // The glossy overlay for the indeterminate progress bar has a small pause
+    // after each animation. We emulate this by adding an invisible margin the
+    // animation has to traverse.
+    int width_with_margin = bar_width + kIndeterminateOverlayPixelsPerSecond;
+    int overlay_width = pre_vista ?
+        kXPIndeterminateOverlayWidth : kVistaIndeterminateOverlayWidth;
+    RECT overlay_rect = bar_rect;
+    overlay_rect.left += ComputeAnimationProgress(
+        width_with_margin, overlay_width, kIndeterminateOverlayPixelsPerSecond,
+        extra.animated_seconds);
+    overlay_rect.right = overlay_rect.left + overlay_width;
+    if (pre_vista) {
+      RECT shrunk_rect = InsetRect(&overlay_rect, kXPBarPadding);
+      RECT shrunk_bar_rect = InsetRect(&bar_rect, kXPBarPadding);
+      draw_theme_(handle, hdc, PP_CHUNK, 0, &shrunk_rect, &shrunk_bar_rect);
+    } else {
+      draw_theme_(handle, hdc, PP_MOVEOVERLAY, 0, &overlay_rect, &bar_rect);
+    }
+    return S_OK;
+  }
+
+  // We care about the direction here because PP_CHUNK painting is asymmetric.
+  // TODO(morrita): This RTL guess can be wrong.  We should pass in the
+  // direction from WebKit.
+  const DTBGOPTS value_draw_options = {
+    sizeof(DTBGOPTS),
+    (bar_rect.right == value_rect.right && bar_rect.left != value_rect.left) ?
+        DTBG_MIRRORDC : 0,
+    bar_rect
+  };
+  if (pre_vista) {
+    // On XP, the progress bar is chunk-style and has no glossy effect.  We need
+    // to shrink the destination rect to fit the part inside the bar with an
+    // appropriate margin.
+    RECT shrunk_value_rect = InsetRect(&value_rect, kXPBarPadding);
+    draw_theme_ex_(handle, hdc, PP_CHUNK, 0, &shrunk_value_rect,
+                   &value_draw_options);
+  } else  {
+    // On Vista or later, the progress bar part has a single-block value part
+    // and a glossy effect.  The value part has exactly same height as the bar
+    // part, so we don't need to shrink the rect.
+    draw_theme_ex_(handle, hdc, PP_FILL, 0, &value_rect, &value_draw_options);
+
+    RECT overlay_rect = value_rect;
+    overlay_rect.left += ComputeAnimationProgress(
+        bar_width, kDeterminateOverlayWidth, kDeterminateOverlayPixelsPerSecond,
+        extra.animated_seconds);
+    overlay_rect.right = overlay_rect.left + kDeterminateOverlayWidth;
+    draw_theme_(handle, hdc, PP_MOVEOVERLAY, 0, &overlay_rect, &value_rect);
+  }
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintWindowResizeGripper(HDC hdc,
                                                  const gfx::Rect& rect) const {
   HANDLE handle = GetThemeHandle(STATUS);
   RECT rect_win = rect.ToRECT();
   if (handle && draw_theme_) {
-    // Paint the status bar gripper.  There doesn't seem to be a
-    // standard gripper in Windows for the space between
-    // scrollbars.  This is pretty close, but it's supposed to be
-    // painted over a status bar.
+    // Paint the status bar gripper.  There doesn't seem to be a standard
+    // gripper in Windows for the space between scrollbars.  This is pretty
+    // close, but it's supposed to be painted over a status bar.
     return draw_theme_(handle, hdc, SP_GRIPPER, 0, &rect_win, NULL);
   }
 
   // Draw a windows classic scrollbar gripper.
   DrawFrameControl(hdc, &rect_win, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintTabPanelBackground(HDC hdc,
                                                 const gfx::Rect& rect) const {
   HANDLE handle = GetThemeHandle(TAB);
   RECT rect_win = rect.ToRECT();
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, TABP_BODY, 0, &rect_win, NULL);
 
   // Classic just renders a flat color background.
   FillRect(hdc, &rect_win, reinterpret_cast<HBRUSH>(COLOR_3DFACE + 1));
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintTextField(
     HDC hdc,
     Part part,
     State state,
     const gfx::Rect& rect,
     const TextFieldExtraParams& extra) const {
-  int part_id = EP_EDITTEXT;
   int state_id = ETS_NORMAL;
   switch (state) {
-    case kNormal:
-      if (extra.is_read_only) {
-        state_id = ETS_READONLY;
-      } else if (extra.is_focused) {
-        state_id = ETS_FOCUSED;
-      } else {
-        state_id = ETS_NORMAL;
-      }
+    case kDisabled:
+      state_id = ETS_DISABLED;
       break;
     case kHovered:
       state_id = ETS_HOT;
       break;
+    case kNormal:
+      if (extra.is_read_only)
+        state_id = ETS_READONLY;
+      else if (extra.is_focused)
+        state_id = ETS_FOCUSED;
+      else
+        state_id = ETS_NORMAL;
+      break;
     case kPressed:
       state_id = ETS_SELECTED;
       break;
-    case kDisabled:
-      state_id = ETS_DISABLED;
-      break;
     default:
-      NOTREACHED() << "Invalid state: " << state;
+      NOTREACHED();
       break;
   }
 
   RECT rect_win = rect.ToRECT();
-  return PaintTextField(hdc, part_id, state_id, extra.classic_state,
+  return PaintTextField(hdc, EP_EDITTEXT, state_id, extra.classic_state,
                         &rect_win,
                         skia::SkColorToCOLORREF(extra.background_color),
                         extra.fill_content_area, extra.draw_edges);
 }
 
 HRESULT NativeThemeWin::PaintTextField(HDC hdc,
                                        int part_id,
                                        int state_id,
                                        int classic_state,
                                        RECT* rect,
                                        COLORREF color,
                                        bool fill_content_area,
                                        bool draw_edges) const {
   // TODO(ojan): http://b/1210017 Figure out how to give the ability to
   // exclude individual edges from being drawn.
 
   HANDLE handle = GetThemeHandle(TEXTFIELD);
   // TODO(mpcomplete): can we detect if the color is specified by the user,
   // and if not, just use the system color?
   // CreateSolidBrush() accepts a RGB value but alpha must be 0.
-  HBRUSH bg_brush = CreateSolidBrush(color);
-  HRESULT hr;
+  base::win::ScopedGDIObject<HBRUSH> bg_brush(CreateSolidBrush(color));
   // DrawThemeBackgroundEx was introduced in XP SP2, so that it's possible
   // draw_theme_ex_ is NULL and draw_theme_ is non-null.
-  if (handle && (draw_theme_ex_ || (draw_theme_ && draw_edges))) {
-    if (draw_theme_ex_) {
-      static const DTBGOPTS omit_border_options = {
-        sizeof(DTBGOPTS),
-        DTBG_OMITBORDER,
-        { 0, 0, 0, 0 }
-      };
-      const DTBGOPTS* draw_opts = draw_edges ? NULL : &omit_border_options;
-      hr = draw_theme_ex_(handle, hdc, part_id, state_id, rect, draw_opts);
-    } else {
-      hr = draw_theme_(handle, hdc, part_id, state_id, rect, NULL);
-    }
-
-    // TODO(maruel): Need to be fixed if get_theme_content_rect_ is NULL.
-    if (fill_content_area && get_theme_content_rect_) {
-      RECT content_rect;
-      hr = get_theme_content_rect_(handle, hdc, part_id, state_id, rect,
-                                   &content_rect);
-      FillRect(hdc, &content_rect, bg_brush);
-    }
-  } else {
+  if (!handle || (!draw_theme_ex_ && (!draw_theme_ || !draw_edges))) {
     // Draw it manually.
     if (draw_edges)
       DrawEdge(hdc, rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
 
     if (fill_content_area) {
       FillRect(hdc, rect, (classic_state & DFCS_INACTIVE) ?
                    reinterpret_cast<HBRUSH>(COLOR_BTNFACE + 1) : bg_brush);
     }
-    hr = S_OK;
+    return S_OK;
   }
-  DeleteObject(bg_brush);
+
+  static const DTBGOPTS omit_border_options = {
+    sizeof(DTBGOPTS),
+    DTBG_OMITBORDER,
+    { 0, 0, 0, 0 }
+  };
+  HRESULT hr = draw_theme_ex_ ?
+    draw_theme_ex_(handle, hdc, part_id, state_id, rect,
+                   draw_edges ? NULL : &omit_border_options) :
+    draw_theme_(handle, hdc, part_id, state_id, rect, NULL);
+
+  // TODO(maruel): Need to be fixed if get_theme_content_rect_ is NULL.
+  if (fill_content_area && get_theme_content_rect_) {
+    RECT content_rect;
+    hr = get_theme_content_rect_(handle, hdc, part_id, state_id, rect,
+                                  &content_rect);
+    FillRect(hdc, &content_rect, bg_brush);
+  }
   return hr;
 }
 
 HRESULT NativeThemeWin::PaintScaledTheme(HANDLE theme,
                                          HDC hdc,
                                          int part_id,
                                          int state_id,
                                          const gfx::Rect& rect) const {
   // Correct the scaling and positioning of sub-components such as scrollbar
   // arrows and thumb grippers in the event that the world transform applies
   // scaling (e.g. in high-DPI mode).
   XFORM save_transform;
   if (GetWorldTransform(hdc, &save_transform)) {
     float scale = save_transform.eM11;
     if (scale != 1 && save_transform.eM12 == 0) {
       ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
-      gfx::Rect scaled_rect = gfx::ToEnclosedRect(
-          gfx::ScaleRect(rect, scale));
-      RECT bounds = gfx::Rect(scaled_rect.x() + save_transform.eDx,
-                              scaled_rect.y() + save_transform.eDy,
-                              scaled_rect.width(),
-                              scaled_rect.height()).ToRECT();
+      gfx::Rect scaled_rect(gfx::ToEnclosedRect(gfx::ScaleRect(rect, scale)));
+      scaled_rect.Offset(save_transform.eDx, save_transform.eDy);
+      RECT bounds = scaled_rect.ToRECT();
       HRESULT result = draw_theme_(theme, hdc, part_id, state_id, &bounds,
                                    NULL);
       SetWorldTransform(hdc, &save_transform);
       return result;
     }
   }
   RECT bounds = rect.ToRECT();
   return draw_theme_(theme, hdc, part_id, state_id, &bounds, NULL);
 }
 
 // static
 NativeThemeWin::ThemeName NativeThemeWin::GetThemeName(Part part) {
-  ThemeName name;
   switch (part) {
     case kCheckbox:
     case kRadio:
     case kPushButton:
-      name = BUTTON;
-      break;
+      return BUTTON;
     case kInnerSpinButton:
-      name = SPIN;
-      break;
+      return SPIN;
     case kMenuCheck:
     case kMenuPopupGutter:
     case kMenuList:
     case kMenuPopupArrow:
     case kMenuPopupSeparator:
-      name = MENU;
-      break;
+      return MENU;
     case kProgressBar:
-      name = PROGRESS;
-      break;
+      return PROGRESS;
     case kScrollbarDownArrow:
     case kScrollbarLeftArrow:
     case kScrollbarRightArrow:
     case kScrollbarUpArrow:
     case kScrollbarHorizontalThumb:
     case kScrollbarVerticalThumb:
     case kScrollbarHorizontalTrack:
     case kScrollbarVerticalTrack:
-      name = SCROLLBAR;
-      break;
+      return SCROLLBAR;
     case kSliderTrack:
     case kSliderThumb:
-      name = TRACKBAR;
-      break;
+      return TRACKBAR;
     case kTextField:
-      name = TEXTFIELD;
-      break;
+      return TEXTFIELD;
     case kWindowResizeGripper:
-      name = STATUS;
-      break;
+      return STATUS;
     default:
-      NOTREACHED() << "Invalid part: " << part;
-      break;
+      NOTREACHED();
+      return LAST;
   }
-  return name;
 }
 
 // static
 int NativeThemeWin::GetWindowsPart(Part part,
                                    State state,
                                    const ExtraParams& extra) {
-  int part_id;
   switch (part) {
     case kCheckbox:
-      part_id = BP_CHECKBOX;
-      break;
+      return BP_CHECKBOX;
     case kMenuCheck:
-      part_id = MENU_POPUPCHECK;
-      break;
+      return MENU_POPUPCHECK;
     case kMenuPopupArrow:
-      part_id = MENU_POPUPSUBMENU;
-      break;
+      return MENU_POPUPSUBMENU;
     case kMenuPopupGutter:
-      part_id = MENU_POPUPGUTTER;
-      break;
+      return MENU_POPUPGUTTER;
     case kMenuPopupSeparator:
-      part_id = MENU_POPUPSEPARATOR;
-      break;
+      return MENU_POPUPSEPARATOR;
     case kPushButton:
-      part_id = BP_PUSHBUTTON;
-      break;
+      return BP_PUSHBUTTON;
     case kRadio:
-      part_id = BP_RADIOBUTTON;
-      break;
+      return BP_RADIOBUTTON;
     case kWindowResizeGripper:
-      part_id = SP_GRIPPER;
-      break;
+      return SP_GRIPPER;
     case kScrollbarDownArrow:
     case kScrollbarLeftArrow:
     case kScrollbarRightArrow:
     case kScrollbarUpArrow:
-      part_id = SBP_ARROWBTN;
-      break;
+      return SBP_ARROWBTN;
     case kScrollbarHorizontalThumb:
-      part_id = SBP_THUMBBTNHORZ;
-      break;
+      return SBP_THUMBBTNHORZ;
     case kScrollbarVerticalThumb:
-      part_id = SBP_THUMBBTNVERT;
-      break;
+      return SBP_THUMBBTNVERT;
     default:
-      NOTREACHED() << "Invalid part: " << part;
-      break;
+      NOTREACHED();
+      return 0;
   }
-  return part_id;
 }
 
 int NativeThemeWin::GetWindowsState(Part part,
                                     State state,
                                     const ExtraParams& extra) {
-  int state_id;
   switch (part) {
     case kCheckbox:
       switch (state) {
-        case kNormal:
-          state_id = CBS_UNCHECKEDNORMAL;
-          break;
-        case kHovered:
-          state_id = CBS_UNCHECKEDHOT;
-          break;
-        case kPressed:
-          state_id = CBS_UNCHECKEDPRESSED;
-          break;
-        case kDisabled:
-          state_id = CBS_UNCHECKEDDISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kDisabled:
+          return CBS_UNCHECKEDDISABLED;
+        case kHovered:
+          return CBS_UNCHECKEDHOT;
+        case kNormal:
+          return CBS_UNCHECKEDNORMAL;
+        case kPressed:
+          return CBS_UNCHECKEDPRESSED;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kMenuCheck:
       switch (state) {
-        case kNormal:
-        case kHovered:
-        case kPressed:
-          state_id = extra.menu_check.is_radio ? MC_BULLETNORMAL
-                                               : MC_CHECKMARKNORMAL;
-          break;
-        case kDisabled:
-          state_id = extra.menu_check.is_radio ? MC_BULLETDISABLED
-                                               : MC_CHECKMARKDISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kDisabled:
+          return extra.menu_check.is_radio ?
+              MC_BULLETDISABLED : MC_CHECKMARKDISABLED;
+        case kHovered:
+        case kNormal:
+        case kPressed:
+          return extra.menu_check.is_radio ?
+              MC_BULLETNORMAL : MC_CHECKMARKNORMAL;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kMenuPopupArrow:
     case kMenuPopupGutter:
     case kMenuPopupSeparator:
       switch (state) {
-        case kNormal:
-          state_id = MBI_NORMAL;
-          break;
-        case kHovered:
-          state_id = MBI_HOT;
-          break;
-        case kPressed:
-          state_id = MBI_PUSHED;
-          break;
-        case kDisabled:
-          state_id = MBI_DISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kDisabled:
+          return MBI_DISABLED;
+        case kHovered:
+          return MBI_HOT;
+        case kNormal:
+          return MBI_NORMAL;
+        case kPressed:
+          return MBI_PUSHED;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kPushButton:
       switch (state) {
-        case kNormal:
-          state_id = PBS_NORMAL;
-          break;
-        case kHovered:
-          state_id = PBS_HOT;
-          break;
-        case kPressed:
-          state_id = PBS_PRESSED;
-          break;
-        case kDisabled:
-          state_id = PBS_DISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kDisabled:
+          return PBS_DISABLED;
+        case kHovered:
+          return PBS_HOT;
+        case kNormal:
+          return PBS_NORMAL;
+        case kPressed:
+          return PBS_PRESSED;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kRadio:
       switch (state) {
-        case kNormal:
-          state_id = RBS_UNCHECKEDNORMAL;
-          break;
-        case kHovered:
-          state_id = RBS_UNCHECKEDHOT;
-          break;
-        case kPressed:
-          state_id = RBS_UNCHECKEDPRESSED;
-          break;
-        case kDisabled:
-          state_id = RBS_UNCHECKEDDISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kDisabled:
+          return RBS_UNCHECKEDDISABLED;
+        case kHovered:
+          return RBS_UNCHECKEDHOT;
+        case kNormal:
+          return RBS_UNCHECKEDNORMAL;
+        case kPressed:
+          return RBS_UNCHECKEDPRESSED;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kWindowResizeGripper:
       switch (state) {
-        case kNormal:
-        case kHovered:
-        case kPressed:
-        case kDisabled:
-          state_id = 1;  // gripper has no windows state
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kDisabled:
+        case kHovered:
+        case kNormal:
+        case kPressed:
+          return 1;  // gripper has no windows state
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kScrollbarDownArrow:
       switch (state) {
-        case kNormal:
-          state_id = ABS_DOWNNORMAL;
-          break;
-        case kHovered:
-          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
-          state_id = base::win::GetVersion() < base::win::VERSION_VISTA ?
+        case kDisabled:
+          return ABS_DOWNDISABLED;
+        case kHovered:
+          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
+          return base::win::GetVersion() < base::win::VERSION_VISTA ?
               ABS_DOWNHOT : ABS_DOWNHOVER;
-          break;
-        case kPressed:
-          state_id = ABS_DOWNPRESSED;
-          break;
-        case kDisabled:
-          state_id = ABS_DOWNDISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kNormal:
+          return ABS_DOWNNORMAL;
+        case kPressed:
+          return ABS_DOWNPRESSED;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kScrollbarLeftArrow:
       switch (state) {
-        case kNormal:
-          state_id = ABS_LEFTNORMAL;
-          break;
-        case kHovered:
-          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
-          state_id = base::win::GetVersion() < base::win::VERSION_VISTA ?
+        case kDisabled:
+          return ABS_LEFTDISABLED;
+        case kHovered:
+          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
+          return base::win::GetVersion() < base::win::VERSION_VISTA ?
               ABS_LEFTHOT : ABS_LEFTHOVER;
-          break;
-        case kPressed:
-          state_id = ABS_LEFTPRESSED;
-          break;
-        case kDisabled:
-          state_id = ABS_LEFTDISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kNormal:
+          return ABS_LEFTNORMAL;
+        case kPressed:
+          return ABS_LEFTPRESSED;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     case kScrollbarRightArrow:
       switch (state) {
-        case kNormal:
-          state_id = ABS_RIGHTNORMAL;
-          break;
-        case kHovered:
-          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
-          state_id = base::win::GetVersion() < base::win::VERSION_VISTA ?
+        case kDisabled:
+          return ABS_RIGHTDISABLED;
+        case kHovered:
+          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
+          return base::win::GetVersion() < base::win::VERSION_VISTA ?
               ABS_RIGHTHOT : ABS_RIGHTHOVER;
-          break;
-        case kPressed:
-          state_id = ABS_RIGHTPRESSED;
-          break;
-        case kDisabled:
-          state_id = ABS_RIGHTDISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
+        case kNormal:
+          return ABS_RIGHTNORMAL;
+        case kPressed:
+          return ABS_RIGHTPRESSED;
+        default:
+          NOTREACHED();
+          return 0;
       }
       break;
     case kScrollbarUpArrow:
       switch (state) {
-        case kNormal:
-          state_id = ABS_UPNORMAL;
-          break;
-        case kHovered:
-          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
-          state_id = base::win::GetVersion() < base::win::VERSION_VISTA ?
+        case kDisabled:
+          return ABS_UPDISABLED;
+        case kHovered:
+          // Mimic ScrollbarThemeChromiumWin.cpp in WebKit.
+          return base::win::GetVersion() < base::win::VERSION_VISTA ?
               ABS_UPHOT : ABS_UPHOVER;
-          break;
-        case kPressed:
-          state_id = ABS_UPPRESSED;
-          break;
-        case kDisabled:
-          state_id = ABS_UPDISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
+        case kNormal:
+          return ABS_UPNORMAL;
+        case kPressed:
+          return ABS_UPPRESSED;
+        default:
+          NOTREACHED();
+          return 0;
       }
       break;
     case kScrollbarHorizontalThumb:
     case kScrollbarVerticalThumb:
       switch (state) {
-        case kNormal:
-          state_id = SCRBS_NORMAL;
-          break;
+        case kDisabled:
+          return SCRBS_DISABLED;
         case kHovered:
           // Mimic WebKit's behaviour in ScrollbarThemeChromiumWin.cpp.
-          state_id = base::win::GetVersion() < base::win::VERSION_VISTA ?
+          return base::win::GetVersion() < base::win::VERSION_VISTA ?
               SCRBS_HOT : SCRBS_HOVER;
-          break;
-        case kPressed:
-          state_id = SCRBS_PRESSED;
-          break;
-        case kDisabled:
-          state_id = SCRBS_DISABLED;
-          break;
-        default:
-          NOTREACHED() << "Invalid state: " << state;
-          break;
-      }
-      break;
+        case kNormal:
+          return SCRBS_NORMAL;
+        case kPressed:
+          return SCRBS_PRESSED;
+        default:
+          NOTREACHED();
+          return 0;
+      }
     default:
-      NOTREACHED() << "Invalid part: " << part;
-      break;
+      NOTREACHED();
+      return 0;
   }
-  return state_id;
 }
 
 HRESULT NativeThemeWin::GetThemeInt(ThemeName theme,
                                     int part_id,
                                     int state_id,
                                     int prop_id,
                                     int *value) const {
   HANDLE handle = GetThemeHandle(theme);
-  if (handle && get_theme_int_)
-    return get_theme_int_(handle, part_id, state_id, prop_id, value);
-  return E_NOTIMPL;
+  return (handle && get_theme_int_) ?
+      get_theme_int_(handle, part_id, state_id, prop_id, value) : E_NOTIMPL;
 }
 
 HRESULT NativeThemeWin::PaintFrameControl(HDC hdc,
                                           const gfx::Rect& rect,
                                           UINT type,
                                           UINT state,
                                           bool is_selected,
                                           State control_state) const {
   const int width = rect.width();
   const int height = rect.height();
 
   // DrawFrameControl for menu arrow/check wants a monochrome bitmap.
   base::win::ScopedBitmap mask_bitmap(CreateBitmap(width, height, 1, 1, NULL));
 
   if (mask_bitmap == NULL)
     return E_OUTOFMEMORY;
 
   base::win::ScopedCreateDC bitmap_dc(CreateCompatibleDC(NULL));
   base::win::ScopedSelectObject select_bitmap(bitmap_dc, mask_bitmap);
   RECT local_rect = { 0, 0, width, height };
   DrawFrameControl(bitmap_dc, &local_rect, type, state);
 
   // We're going to use BitBlt with a b&w mask. This results in using the dest
   // dc's text color for the black bits in the mask, and the dest dc's
   // background color for the white bits in the mask. DrawFrameControl draws the
   // check in black, and the background in white.
   int bg_color_key;
   int text_color_key;
   switch (control_state) {
+    case NativeTheme::kDisabled:
+      bg_color_key = is_selected ? COLOR_HIGHLIGHT : COLOR_MENU;
+      text_color_key = COLOR_GRAYTEXT;
+      break;
     case NativeTheme::kHovered:
       bg_color_key = COLOR_HIGHLIGHT;
       text_color_key = COLOR_HIGHLIGHTTEXT;
       break;
     case NativeTheme::kNormal:
       bg_color_key = COLOR_MENU;
       text_color_key = COLOR_MENUTEXT;
       break;
-    case NativeTheme::kDisabled:
-      bg_color_key = is_selected ? COLOR_HIGHLIGHT : COLOR_MENU;
-      text_color_key = COLOR_GRAYTEXT;
-      break;
     default:
       NOTREACHED();
       bg_color_key = COLOR_MENU;
       text_color_key = COLOR_MENUTEXT;
       break;
   }
   COLORREF old_bg_color = SetBkColor(hdc, GetSysColor(bg_color_key));
   COLORREF old_text_color = SetTextColor(hdc, GetSysColor(text_color_key));
   BitBlt(hdc, rect.x(), rect.y(), width, height, bitmap_dc, 0, 0, SRCCOPY);
   SetBkColor(hdc, old_bg_color);
@@ skipping 43 matching lines @@
     handle = open_theme_(NULL, L"Window");
     break;
   case PROGRESS:
     handle = open_theme_(NULL, L"Progress");
     break;
   case SPIN:
     handle = open_theme_(NULL, L"Spin");
     break;
   default:
     NOTREACHED();
+    break;
   }
   theme_handles_[theme_name] = handle;
   return handle;
 }
 
 }  // namespace ui