Remove some LazyInstance use in base/

base/win/message_window.cc

 // Copyright 2013 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 "base/win/message_window.h"
 
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/win/current_module.h"
 #include "base/win/wrapped_window_proc.h"
 
 const wchar_t kMessageWindowClassName[] = L"Chrome_MessageWindow";
 
 namespace base {
 namespace win {
 
-// Used along with LazyInstance to register a window class for message-only
-// windows created by MessageWindow.
+// Used along with a threadsafe static pointer to register a window class for
+// message-only windows created by MessageWindow.
 class MessageWindow::WindowClass {
  public:
   WindowClass();
   ~WindowClass();
 
   ATOM atom() { return atom_; }
   HINSTANCE instance() { return instance_; }
 
  private:
   ATOM atom_;
   HINSTANCE instance_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowClass);
 };
 
-static LazyInstance<MessageWindow::WindowClass> g_window_class =

[Mark Mentovai, 2017/01/31 14:37:01]

This wasn’t leaky, and WindowClass has a destructor that does more than nothing.
How do you want to handle it?

[scottmg, 2017/01/31 18:19:16]

For general process shutdown, there's little point to UnregisterClass()ing, but
I guess the DCHECK potentially has some minor value in detecting leaks.

Hmm... I guess we might want a general helper function that either does both the
new'ing and OnExit() registration. But here, I think I'll just call
AtExitManager::RegisterCallback() for now, until we see how many non-leaky
things we truly want.

-    LAZY_INSTANCE_INITIALIZER;
-
 MessageWindow::WindowClass::WindowClass()
     : atom_(0), instance_(CURRENT_MODULE()) {
   WNDCLASSEX window_class;
   window_class.cbSize = sizeof(window_class);
   window_class.style = 0;
   window_class.lpfnWndProc = &base::win::WrappedWindowProc<WindowProc>;
   window_class.cbClsExtra = 0;
   window_class.cbWndExtra = 0;
   window_class.hInstance = instance_;
   window_class.hIcon = NULL;
@@ skipping 49 matching lines @@
 }
 
 bool MessageWindow::DoCreate(const MessageCallback& message_callback,
                              const wchar_t* window_name) {
   DCHECK(CalledOnValidThread());
   DCHECK(message_callback_.is_null());
   DCHECK(!window_);
 
   message_callback_ = message_callback;
 
-  WindowClass& window_class = g_window_class.Get();
-  window_ = CreateWindow(MAKEINTATOM(window_class.atom()), window_name, 0, 0, 0,
-                         0, 0, HWND_MESSAGE, 0, window_class.instance(), this);
+  static auto window_class = new WindowClass();
+  window_ =
+      CreateWindow(MAKEINTATOM(window_class->atom()), window_name, 0, 0, 0, 0,
+                   0, HWND_MESSAGE, 0, window_class->instance(), this);
   if (!window_) {
     PLOG(ERROR) << "Failed to create a message-only window";
     return false;
   }
 
   return true;
 }
 
 // static
 LRESULT CALLBACK MessageWindow::WindowProc(HWND hwnd,
@@ skipping 36 matching lines @@
     LRESULT message_result;
     if (self->message_callback_.Run(message, wparam, lparam, &message_result))
       return message_result;
   }
 
   return DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 }  // namespace win
 }  // namespace base