Rename ScopedHDC to ScopedCreateDC

ui/gfx/native_theme_win.cc

 // Copyright (c) 2011 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/gfx/native_theme_win.h"
 
 #include <windows.h>
 #include <uxtheme.h>
 #include <vsstyle.h>
 #include <vssym32.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_handle.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
+#include "base/win/scoped_select_object.h"
 #include "base/win/windows_version.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/rect.h"
 
 namespace {
@@ skipping 76 matching lines @@
     get_theme_int_ = reinterpret_cast<GetThemeIntPtr>(
         GetProcAddress(theme_dll_, "GetThemeInt"));
   }
   memset(theme_handles_, 0, sizeof(theme_handles_));
 }
 
 NativeThemeWin::~NativeThemeWin() {
   if (theme_dll_) {
     // todo (cpu): fix this soon.  Making a call to CloseHandles() here breaks
     // certain tests and the reliability bots.
-    //CloseHandles();
+    // CloseHandles();
     FreeLibrary(theme_dll_);
   }
 }
 
 gfx::Size NativeThemeWin::GetPartSize(Part part,
                                       State state,
                                       const ExtraParams& extra) const {
   SIZE size;
   int part_id = GetWindowsPart(part, state, extra);
   int state_id = GetWindowsState(part, state, extra);
@@ skipping 206 matching lines @@
   RECT rect_win = rect.ToRECT();
   if (handle && draw_theme_) {
     int index = part - kScrollbarDownArrow;
     DCHECK(index >=0 && index < 4);
     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) {
+      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;
           break;
       }
     }
 
     return draw_theme_(handle, hdc, SBP_ARROWBTN, state_id, &rect_win, NULL);
   }
 
   int classic_state = DFCS_SCROLLDOWN;
-  switch(part) {
+  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;
       break;
   }
-  switch(state) {
+  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;
@@ skipping 11 matching lines @@
     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) {
+  switch (part) {
     case gfx::NativeTheme::kScrollbarHorizontalTrack:
       part_id = extra.is_upper ? SBP_UPPERTRACKHORZ : SBP_LOWERTRACKHORZ;
       break;
     case gfx::NativeTheme::kScrollbarVerticalTrack:
       part_id = extra.is_upper ? SBP_UPPERTRACKVERT : SBP_LOWERTRACKVERT;
       break;
     default:
       NOTREACHED() << "Invalid part: " << part;
       break;
   }
 
-  switch(state) {
+  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:
@@ skipping 29 matching lines @@
     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) {
+  switch (part) {
     case gfx::NativeTheme::kScrollbarHorizontalThumb:
       part_id = SBP_THUMBBTNHORZ;
       break;
     case gfx::NativeTheme::kScrollbarVerticalThumb:
       part_id = SBP_THUMBBTNVERT;
       break;
     case gfx::NativeTheme::kScrollbarHorizontalGripper:
       part_id = SBP_GRIPPERHORZ;
       break;
     case gfx::NativeTheme::kScrollbarVerticalGripper:
       part_id = SBP_GRIPPERVERT;
       break;
     default:
       NOTREACHED() << "Invalid part: " << part;
       break;
   }
 
-  switch(state) {
+  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:
@@ skipping 13 matching lines @@
   // Classic mode doesn't have a gripper.
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintPushButton(HDC hdc,
                                         Part part,
                                         State state,
                                         const gfx::Rect& rect,
                                         const ButtonExtraParams& extra) const {
   int state_id;
-  switch(state) {
+  switch (state) {
     case kDisabled:
       state_id = PBS_DISABLED;
       break;
     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;
       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) {
+  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;
       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) {
+  switch (state) {
     case kDisabled:
       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;
       break;
@@ skipping 21 matching lines @@
                                     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) {
+  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;
       break;
   }
 
-  switch(state) {
+  switch (state) {
     case kDisabled:
       classic_state |= DFCS_INACTIVE;
       break;
     case kPressed:
       classic_state |= DFCS_PUSHED;
       break;
     case kNormal:
     case kHovered:
       break;
     default:
@@ skipping 50 matching lines @@
   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.
       Rect r(rect);
-      base::win::ScopedHDC mem_dc(CreateCompatibleDC(hdc));
+      base::win::ScopedCreateDC mem_dc(CreateCompatibleDC(hdc));
       base::win::ScopedBitmap mem_bitmap(CreateCompatibleBitmap(hdc, r.width(),
                                                                 r.height()));
-      HGDIOBJ old_bitmap = SelectObject(mem_dc, mem_bitmap);
+      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);
-      SelectObject(mem_dc, old_bitmap);
       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;
@@ skipping 65 matching lines @@
 }
 
 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) {
+  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;
     default:
       NOTREACHED() << "Invalid state " << state;
       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;
 }
 
 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) {
+  switch (state) {
     case kNormal:
       state_id = CBXS_NORMAL;
       break;
     case kDisabled:
       state_id = CBXS_DISABLED;
       break;
     case kHovered:
       state_id = CBXS_HOT;
       break;
     case kPressed:
@@ skipping 38 matching lines @@
 HRESULT NativeThemeWin::PaintSpinButton(
     HDC hdc,
     Part part,
     State state,
     const gfx::Rect& rect,
     const InnerSpinButtonExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(SPIN);
   RECT rect_win = rect.ToRECT();
   int part_id = extra.spin_up ? SPNP_UP : SPNP_DOWN;
   int state_id;
-  switch(state) {
+  switch (state) {
     case kDisabled:
       state_id = extra.spin_up ? UPS_DISABLED : DNS_DISABLED;
       break;
     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:
@@ skipping 44 matching lines @@
     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;
 
   int state_id = 0;
-  switch(state) {
+  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:
@@ skipping 206 matching lines @@
 }
 
 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) {
+  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;
       }
       break;
     case kHovered:
@@ skipping 34 matching lines @@
   // CreateSolidBrush() accepts a RGB value but alpha must be 0.
   HBRUSH bg_brush = CreateSolidBrush(color);
   HRESULT hr;
   // 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 DTBGOPTS omit_border_options = {
         sizeof(DTBGOPTS),
         DTBG_OMITBORDER,
-        {0,0,0,0}
+        { 0, 0, 0, 0 }
       };
       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;
@@ skipping 100 matching lines @@
                                           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::ScopedHDC bitmap_dc(CreateCompatibleDC(NULL));
-  HGDIOBJ org_bitmap = SelectObject(bitmap_dc, mask_bitmap);
+  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) {
@@ skipping 14 matching lines @@
       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);
   SetTextColor(hdc, old_text_color);
 
-  SelectObject(bitmap_dc, org_bitmap);
-
   return S_OK;
 }
 
 void NativeThemeWin::CloseHandles() const {
   if (!close_theme_)
     return;
 
   for (int i = 0; i < LAST; ++i) {
     if (theme_handles_[i]) {
       close_theme_(theme_handles_[i]);
@@ skipping 58 matching lines @@
   default:
     NOTREACHED();
   }
   theme_handles_[theme_name] = handle;
   return handle;
 }
 
 // static
 NativeThemeWin::ThemeName NativeThemeWin::GetThemeName(Part part) {
   ThemeName name;
-  switch(part) {
+  switch (part) {
     case kCheckbox:
     case kRadio:
     case kPushButton:
       name = BUTTON;
       break;
     case kInnerSpinButton:
       name = SPIN;
       break;
     case kMenuCheck:
     case kMenuPopupGutter:
@@ skipping 30 matching lines @@
       break;
   }
   return name;
 }
 
 // static
 int NativeThemeWin::GetWindowsPart(Part part,
                                    State state,
                                    const ExtraParams& extra) {
   int part_id;
-  switch(part) {
+  switch (part) {
     case kCheckbox:
       part_id = BP_CHECKBOX;
       break;
     case kMenuCheck:
       part_id = MENU_POPUPCHECK;
       break;
     case kMenuPopupArrow:
       part_id = MENU_POPUPSUBMENU;
       break;
     case kMenuPopupGutter:
@@ skipping 15 matching lines @@
       NOTREACHED() << "Invalid part: " << part;
       break;
   }
   return part_id;
 }
 
 int NativeThemeWin::GetWindowsState(Part part,
                                     State state,
                                     const ExtraParams& extra) {
   int state_id;
-  switch(part) {
+  switch (part) {
     case kCheckbox:
-      switch(state) {
+      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 kMenuCheck:
-      switch(state) {
+      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 kMenuPopupArrow:
     case kMenuPopupGutter:
     case kMenuPopupSeparator:
-      switch(state) {
+      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 kPushButton:
-      switch(state) {
+      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 kRadio:
-      switch(state) {
+      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 kWindowResizeGripper:
-      switch(state) {
+      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;
     default:
       NOTREACHED() << "Invalid part: " << part;
       break;
   }
   return state_id;
 }
 
 }  // namespace gfx