Deregister window classes

ui/gfx/win/window_impl.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/gfx/win/window_impl.h"
 
 #include <list>
 
 #include "base/debug/alias.h"
 #include "base/memory/singleton.h"
@@ skipping 32 matching lines @@
   }
 };
 
 // WARNING: this class may be used on multiple threads.
 class ClassRegistrar {
  public:
   ~ClassRegistrar();
 
   static ClassRegistrar* GetInstance();
 
+  void set_unregister_at_exit(bool unregister_at_exit) {
+    unregister_at_exit_ = unregister_at_exit;
+  }
+
   // Returns the atom identifying the class matching |class_info|,
   // creating and registering a new class if the class is not yet known.
   ATOM RetrieveClassAtom(const ClassInfo& class_info);
 
  private:
   // Represents a registered window class.
   struct RegisteredClass {
-    RegisteredClass(const ClassInfo& info, ATOM atom);
+    RegisteredClass(const ClassInfo& info,
+                    base::string16 name,
+                    ATOM atom,
+                    HINSTANCE instance);
 
     // Info used to create the class.
     ClassInfo info;
 
+    // The name given to the window class
+    base::string16 name;
+
     // The atom identifying the window class.
     ATOM atom;
+
+    // The handle of the module containing the window proceedure.
+    HMODULE instance;
   };
 
   ClassRegistrar();
   friend struct DefaultSingletonTraits<ClassRegistrar>;
 
   typedef std::list<RegisteredClass> RegisteredClasses;
   RegisteredClasses registered_classes_;
 
   // Counter of how many classes have been registered so far.
   int registered_count_;
 
+  // If true all registered classes will be unregistered upon exit.
+  bool unregister_at_exit_;
+
   base::Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ClassRegistrar);
 };
 
-ClassRegistrar::~ClassRegistrar() {}
+ClassRegistrar::~ClassRegistrar() {
+  if (!unregister_at_exit_)
+    return;
+
+  for (RegisteredClasses::iterator i = registered_classes_.begin();
+        i != registered_classes_.end(); ++i) {
+     if (!UnregisterClass(MAKEINTATOM(i->atom), i->instance)) {
+       LOG(ERROR) << "Failed to unregister class " << i->name
+                  << ". Error = " << GetLastError();
+     }
+   }
+ }
 
 // static
 ClassRegistrar* ClassRegistrar::GetInstance() {
-  return Singleton<ClassRegistrar,
-                   LeakySingletonTraits<ClassRegistrar> >::get();
+  return Singleton<ClassRegistrar>::get();
 }
 
 ATOM ClassRegistrar::RetrieveClassAtom(const ClassInfo& class_info) {
   base::AutoLock auto_lock(lock_);
   for (RegisteredClasses::const_iterator i = registered_classes_.begin();
        i != registered_classes_.end(); ++i) {
     if (class_info.Equals(i->info))
       return i->atom;
   }
 
@@ skipping 11 matching lines @@
       NULL,
       reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)),
       NULL,
       class_info.icon,
       class_info.icon,
       &window_class);
   HMODULE instance = window_class.hInstance;
   ATOM atom = RegisterClassEx(&window_class);
   CHECK(atom) << GetLastError();
 
-  registered_classes_.push_back(RegisteredClass(class_info, atom));
+  registered_classes_.push_back(RegisteredClass(
+      class_info, name, atom, instance));
 
   return atom;
 }
 
 ClassRegistrar::RegisteredClass::RegisteredClass(const ClassInfo& info,
-                                                 ATOM atom)
+                                                 base::string16 name,
+                                                 ATOM atom,
+                                                 HMODULE instance)
     : info(info),
-      atom(atom) {}
+      name(name),
+      atom(atom),
+      instance(instance) {}
 
-ClassRegistrar::ClassRegistrar() : registered_count_(0) {}
+ClassRegistrar::ClassRegistrar()
+    : registered_count_(0),
+      unregister_at_exit_(false) {}
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowImpl, public
 
 WindowImpl::WindowImpl()
     : window_style_(0),
       window_ex_style_(kWindowDefaultExStyle),
       class_style_(CS_DBLCLKS),
       hwnd_(NULL),
       got_create_(false),
       got_valid_hwnd_(false),
       destroyed_(NULL) {
 }
 
 WindowImpl::~WindowImpl() {
   if (destroyed_)
     *destroyed_ = true;
   ClearUserData();
 }
 
+// static
+void WindowImpl::SetUnregisterClassesAtExit(bool unregister_classes_at_exit) {
+  ClassRegistrar::GetInstance()->set_unregister_at_exit(
+      unregister_classes_at_exit);
+}
+
 void WindowImpl::Init(HWND parent, const Rect& bounds) {
   if (window_style_ == 0)
     window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle;
 
   if (parent == HWND_DESKTOP) {
     // Only non-child windows can have HWND_DESKTOP (0) as their parent.
     CHECK((window_style_ & WS_CHILD) == 0);
     parent = GetWindowToParentTo(false);
   } else if (parent == ::GetDesktopWindow()) {
     // Any type of window can have the "Desktop Window" as their parent.
@@ skipping 105 matching lines @@
   return window->OnWndProc(message, w_param, l_param);
 }
 
 ATOM WindowImpl::GetWindowClassAtom() {
   HICON icon = GetDefaultWindowIcon();
   ClassInfo class_info(initial_class_style(), icon);
   return ClassRegistrar::GetInstance()->RetrieveClassAtom(class_info);
 }
 
 }  // namespace gfx