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/at_exit.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 =
-    LAZY_INSTANCE_INITIALIZER;
+MessageWindow::WindowClass* GetWindowClass() {
+  static MessageWindow::WindowClass* window_class = []() {
+    auto ret = new MessageWindow::WindowClass();
+    auto deleter = [](void* p) {
+      delete reinterpret_cast<MessageWindow::WindowClass*>(p);
+    };
+    AtExitManager::RegisterCallback(deleter, ret);

[scottmg, 2017/01/31 21:27:43]

This "quick fix" is incorrect because in tests there's an pseudo AtExitManager
that runs and even though the process isn't shutting down we run the AtExits and
reset lazy instances.

I'm going to revert message_window.* out of this CL for now. I think likely the
correct thing to do here is just make it truly leaky.

+    return ret;
+  }();
+  return window_class;
+}
 
 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_;
@@ skipping 50 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);
+  window_ =
+      CreateWindow(MAKEINTATOM(GetWindowClass()->atom()), window_name, 0, 0, 0,
+                   0, 0, HWND_MESSAGE, 0, GetWindowClass()->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