Make scoped dc objects smarter.

base/win/scoped_hdc.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
 #ifndef BASE_WIN_SCOPED_HDC_H_
 #define BASE_WIN_SCOPED_HDC_H_
 #pragma once
 
 #include <windows.h>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
 
 namespace base {
 namespace win {
 
-// Like ScopedHandle but for HDC.  Only use this on HDCs returned from
-// GetDC.
-class ScopedGetDC {
+// The ScopedGetDC and ScopedCreateDC classes manage the default GDI objects
+// that are initially selected into a DC. They help you avoid the following
+// common mistake:
+//
+// HDC hdc = GetDC(NULL);
+// SelectObject(hdc, new_bitmap);
+// .. drawing code here ..
+// ReleaseDC(hdc);   <--- error: the DC has a custom object still selected!
+//
+// This code should be:
+//
+// HDC hdc = GetDC(NULL);
+// HGDIOBJ old_obj = SelectObject(hdc, new_bitmap);
+// .. drawing code here ..
+// SelectObject(hdc, old_obj);
+// ReleaseDC(hdc);    <--- ok to release now.
+//
+// But why work so hard? Use our handy classes:
+//
+// ScopedGetDC dc(NULL);
+// dc.SelectBitmap(hdc, new_bitmap);
+// .. drawing here
+// .. when dc goes out of scope it will select the original object before
+// .. being released.
+//
+class ScopedDC {
+ public:
+  virtual ~ScopedDC() {}
+
+  virtual void DisposeDC(HDC hdc) = 0;
+
+  HDC Get() {
+    return hdc_;
+  }
+
+  operator HDC() {
+    return hdc_;
+  }
+
+  void SelectBitmap(HBITMAP bitmap) {
+    Select(bitmap, &bitmap_);
+  }
+
+  void SelectFont(HFONT font) {
+    Select(font, &font_);
+  }
+
+  void SelectBrush(HBRUSH brush) {
+    Select(brush, &brush_);
+  }
+
+  void SelectPen(HPEN pen) {
+    Select(pen, &pen_);
+  }
+
+  void SelectRegion(HRGN region) {
+    Select(region, &region_);
+  }
+
+ protected:
+  ScopedDC(HDC hdc)
+    : hdc_(hdc), bitmap_(0), font_(0), brush_(0), pen_(0), region_(0) {
+  }
+
+  void Close() {
+    if (!hdc_)
+      return;
+    ResetObjects();
+    DisposeDC(hdc_);
+  }
+
+  void Reset(HDC hdc) {

[Peter Kasting, 2012/01/24 21:03:26]

Nit: We can eliminate this and inline it into the lone caller.

(That will make it less likely that we preserve this code once we kill said
caller.)

+    Close();
+    hdc_ = hdc;
+  }
+
+ private:
+  void ResetObjects() {
+    if (bitmap_) {
+      SelectObject(hdc_, bitmap_);
+      bitmap_ = 0;
+    }
+    if (font_) {
+      SelectObject(hdc_, font_);
+      font_ = 0;
+    }
+    if (brush_) {
+      SelectObject(hdc_, brush_);
+      brush_ = 0;
+    }
+    if (pen_) {
+      SelectObject(hdc_, pen_);
+      pen_ = 0;
+    }
+    if (region_) {
+      SelectObject(hdc_, region_);
+      region_ = 0;
+    }
+  }
+
+  void Select(HGDIOBJ object, HGDIOBJ* holder) {
+    HGDIOBJ old = SelectObject(hdc_, object);
+    DCHECK(old);
+    // We only want to store the first |old| object.
+    if (!*holder)
+      *holder = old;
+  }
+
+  HDC hdc_;
+  HGDIOBJ bitmap_;
+  HGDIOBJ font_;
+  HGDIOBJ brush_;
+  HGDIOBJ pen_;
+  HGDIOBJ region_;
+};
+
+// Creates and manages a HDC obtained by GetDC.
+class ScopedGetDC : public ScopedDC  {
  public:
   explicit ScopedGetDC(HWND hwnd)
-      : hwnd_(hwnd),
-        hdc_(GetDC(hwnd)) {
-    DCHECK(!hwnd_ || IsWindow(hwnd_));
-    DCHECK(hdc_);
+    : ScopedDC(GetDC(hwnd)), hwnd_(hwnd) {
   }
 
-  ~ScopedGetDC() {
-    if (hdc_)
-      ReleaseDC(hwnd_, hdc_);
+  virtual ~ScopedGetDC() {
+    Close();
   }
 
-  operator HDC() { return hdc_; }
+ private:
+  virtual void DisposeDC(HDC hdc) OVERRIDE {
+    ReleaseDC(hwnd_, hdc);
+  }
 
- private:
   HWND hwnd_;
-  HDC hdc_;
-
   DISALLOW_COPY_AND_ASSIGN(ScopedGetDC);
 };
 
 // Like ScopedHandle but for HDC.  Only use this on HDCs returned from
 // CreateCompatibleDC, CreateDC and CreateIC.
-class ScopedCreateDC {
+class ScopedCreateDC : public ScopedDC {
  public:
-  ScopedCreateDC() : hdc_(NULL) { }
-  explicit ScopedCreateDC(HDC h) : hdc_(h) { }
+  ScopedCreateDC()
+    : ScopedDC(0) {
+  }
 
-  ~ScopedCreateDC() {
+  explicit ScopedCreateDC(HDC hdc)
+    : ScopedDC(hdc) {
+  }
+
+  virtual ~ScopedCreateDC() {
     Close();
   }
 
-  HDC Get() {
-    return hdc_;
+  void Set(HDC hdc) {
+    Reset(hdc);
   }
 
-  void Set(HDC h) {
-    Close();
-    hdc_ = h;
+ private:
+  virtual void DisposeDC(HDC hdc) OVERRIDE {
+    DeleteDC(hdc);
   }
 
-  operator HDC() { return hdc_; }
-
- private:
-  void Close() {
-#ifdef NOGDI
-    assert(false);
-#else
-    if (hdc_)
-      DeleteDC(hdc_);
-#endif  // NOGDI
-  }
-
-  HDC hdc_;
-
   DISALLOW_COPY_AND_ASSIGN(ScopedCreateDC);
 };
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_WIN_SCOPED_HDC_H_