Ensure Windows window classes are unregistered on shutdown (take 2)

chrome/views/widget/widget_win.cc

 // Copyright (c) 2006-2008 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 "chrome/views/widget/widget_win.h"
 
 #include "base/gfx/native_theme.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 24 matching lines @@
 
 RootView* GetRootViewForHWND(HWND hwnd) {
   return reinterpret_cast<RootView*>(::GetProp(hwnd, kRootViewWindowProperty));
 }
 
 NativeControlWin* GetNativeControlWinForHWND(HWND hwnd) {
   return reinterpret_cast<NativeControlWin*>(
       ::GetProp(hwnd, NativeControlWin::kNativeControlWinKey));
 }
 
-// Used to locate the WidgetWin issuing the current Create. Only valid for the
-// life of Create.
-//
-// This obviously assumes we only create WidgetWins from the same thread,
-// which is currently the case.
-static WidgetWin* instance_issuing_create = NULL;
-
 ///////////////////////////////////////////////////////////////////////////////
 // Window class tracking.
 
 // static
 const wchar_t* const WidgetWin::kBaseClassName =
     L"Chrome_WidgetWin_";
 
 // Window class information used for registering unique windows.
 struct ClassInfo {
   UINT style;
   HBRUSH background;
 
   explicit ClassInfo(int style)
       : style(style),
         background(NULL) {}
 
   // Compares two ClassInfos. Returns true if all members match.
-  bool Equals(const ClassInfo& other) {
+  bool Equals(const ClassInfo& other) const {
     return (other.style == style && other.background == background);
   }
 };
 
-// Represents a registered window class.
-struct RegisteredClass {
-  RegisteredClass(const ClassInfo& info,
-                  const std::wstring& name,
-                  ATOM atom)
-      : info(info),
-        name(name),
-        atom(atom) {
+class ClassRegistrar {
+ public:
+  ~ClassRegistrar() {
+    for (RegisteredClasses::iterator i = registered_classes_.begin();
+         i != registered_classes_.end(); ++i) {
+      UnregisterClass(i->name.c_str(), NULL);
+    }
   }
 
-  // Info used to create the class.
-  ClassInfo info;
+  // Puts the name for the class matching |class_info| in |class_name|, creating
+  // a new name if the class is not yet known.
+  // Returns true if this class was already known, false otherwise.
+  bool RetrieveClassName(const ClassInfo& class_info, std::wstring* name) {
+    for (RegisteredClasses::const_iterator i = registered_classes_.begin();
+         i != registered_classes_.end(); ++i) {
+      if (class_info.Equals(i->info)) {
+        name->assign(i->name);
+        return true;
+      }
+    }
 
-  // The name given to the window.
-  std::wstring name;
+    name->assign(std::wstring(WidgetWin::kBaseClassName) +
+        IntToWString(registered_count_++));
+    return false;
+  }
 
-  // The ATOM returned from creating the window.
-  ATOM atom;
+  void RegisterClass(const ClassInfo& class_info,
+                     const std::wstring& name,
+                     ATOM atom) {
+    registered_classes_.push_back(RegisteredClass(class_info, name, atom));
+  }
+
+ private:
+  // Represents a registered window class.
+  struct RegisteredClass {
+    RegisteredClass(const ClassInfo& info,
+                    const std::wstring& name,
+                    ATOM atom)
+        : info(info),
+          name(name),
+          atom(atom) {
+    }
+
+    // Info used to create the class.
+    ClassInfo info;
+
+    // The name given to the window.
+    std::wstring name;
+
+    // The ATOM returned from creating the window.
+    ATOM atom;
+  };
+
+  ClassRegistrar() : registered_count_(0) { }
+  friend struct DefaultSingletonTraits<ClassRegistrar>;
+
+  typedef std::list<RegisteredClass> RegisteredClasses;
+  RegisteredClasses registered_classes_;
+
+  // Counter of how many classes have ben registered so far.
+  int registered_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClassRegistrar);
 };
 
-typedef std::list<RegisteredClass> RegisteredClasses;
-
-// The list of registered classes.
-static RegisteredClasses* registered_classes = NULL;
-
-
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public
 
 WidgetWin::WidgetWin()
     : close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       has_capture_(false),
       current_action_(FA_NONE),
       window_style_(0),
       window_ex_style_(kWindowDefaultExStyle),
@@ skipping 738 matching lines @@
     CPoint window_position = wr.TopLeft();
 
     BLENDFUNCTION blend = {AC_SRC_OVER, 0, layered_alpha_, AC_SRC_ALPHA};
     ::UpdateLayeredWindow(
         hwnd_, NULL, &window_position, &size, dib_dc, &zero_origin,
         RGB(0xFF, 0xFF, 0xFF), &blend, ULW_ALPHA);
   }
 }
 
 std::wstring WidgetWin::GetWindowClassName() {
-  if (!registered_classes)
-    registered_classes = new RegisteredClasses();
   ClassInfo class_info(initial_class_style());
-  for (RegisteredClasses::iterator i = registered_classes->begin();
-       i != registered_classes->end(); ++i) {
-    if (class_info.Equals(i->info))
-      return i->name;
-  }
+  std::wstring name;
+  if (Singleton<ClassRegistrar>()->RetrieveClassName(class_info, &name))
+    return name;
 
   // No class found, need to register one.
-  static int registered_count = 0;
-  std::wstring name =
-      std::wstring(kBaseClassName) + IntToWString(registered_count++);
   WNDCLASSEX class_ex;
   class_ex.cbSize = sizeof(WNDCLASSEX);
   class_ex.style = class_info.style;
   class_ex.lpfnWndProc = &WidgetWin::WndProc;
   class_ex.cbClsExtra = 0;
   class_ex.cbWndExtra = 0;
   class_ex.hInstance = NULL;
   class_ex.hIcon = LoadIcon(GetModuleHandle(L"chrome.dll"),
                             MAKEINTRESOURCE(IDR_MAINFRAME));
   class_ex.hCursor = LoadCursor(NULL, IDC_ARROW);
   class_ex.hbrBackground = reinterpret_cast<HBRUSH>(class_info.background + 1);
   class_ex.lpszMenuName = NULL;
   class_ex.lpszClassName = name.c_str();
   class_ex.hIconSm = class_ex.hIcon;
   ATOM atom = RegisterClassEx(&class_ex);
   DCHECK(atom);
-  RegisteredClass registered_class(class_info, name, atom);
-  registered_classes->push_back(registered_class);
+
+  Singleton<ClassRegistrar>()->RegisterClass(class_info, name, atom);
+
   return name;
 }
 
 // Get the source HWND of the specified message. Depending on the message, the
 // source HWND is encoded in either the WPARAM or the LPARAM value.
 HWND GetControlHWNDForMessage(UINT message, WPARAM w_param, LPARAM l_param) {
   // Each of the following messages can be sent by a child HWND and must be
   // forwarded to its associated NativeControlWin for handling.
   switch (message) {
     case WM_NOTIFY:
@@ skipping 63 matching lines @@
     result = DefWindowProc(window, message, w_param, l_param);
   if (message == WM_NCDESTROY) {
     TRACK_HWND_DESTRUCTION(window);
     widget->hwnd_ = NULL;
     widget->OnFinalMessage(window);
   }
   return result;
 }
 
 }  // namespace views