Two HandleVerifier thread safety fixes.

base/win/scoped_handle.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 "base/win/scoped_handle.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 
@@ skipping 99 matching lines @@
   if (!g_active_verifier)
     ActiveVerifier::InstallVerifier();
 
   return g_active_verifier;
 }
 
 // static
 void ActiveVerifier::InstallVerifier() {
 #if defined(COMPONENT_BUILD)
   AutoNativeLock lock(g_lock.Get());
+  if (g_active_verifier)
+    return;
   g_active_verifier = new ActiveVerifier(true);
 #else
   // If you are reading this, wondering why your process seems deadlocked, take
   // a look at your DllMain code and remove things that should not be done
   // there, like doing whatever gave you that nice windows handle you are trying
   // to store in a ScopedHandle.
   HMODULE main_module = ::GetModuleHandle(NULL);
   GetHandleVerifierFn get_handle_verifier =
       reinterpret_cast<GetHandleVerifierFn>(::GetProcAddress(
           main_module, "GetHandleVerifier"));
 
+  // This should only happen if running in a DLL is linked with base but the
+  // hosting EXE is not. In this case, create an ActiveVerifier for the current
+  // module but leave it disabled.
   if (!get_handle_verifier) {
     g_active_verifier = new ActiveVerifier(false);
     return;
   }
 
-  ActiveVerifier* verifier =
+  // Check if in the main module.
+  if (get_handle_verifier == GetHandleVerifier) {
+    AutoNativeLock lock(g_lock.Get());
+    if (g_active_verifier)
+      return;
+    g_active_verifier = new ActiveVerifier(true);
+    return;
+  }
+
+  ActiveVerifier* main_module_verifier =
       reinterpret_cast<ActiveVerifier*>(get_handle_verifier());
 
+  // Main module should always on-demand create a verifier.
+  DCHECK(main_module_verifier);
+
   // This lock only protects against races in this module, which is fine.
   AutoNativeLock lock(g_lock.Get());
-  g_active_verifier = verifier ? verifier : new ActiveVerifier(true);
+  if (g_active_verifier)

[scottmg, 2016/03/10 20:31:26]

Maybe an extra comment here describing what we discussed about this part.

[Will Harris, 2016/03/10 21:08:45]

Done.

+    return;
+  g_active_verifier = main_module_verifier;
 #endif
 }
 
 bool ActiveVerifier::CloseHandle(HANDLE handle) {
   if (!enabled_)
     return CloseHandleWrapper(handle);
 
   closing_.Set(true);
   CloseHandleWrapper(handle);
   closing_.Set(false);
@@ skipping 62 matching lines @@
 
   Info other = i->second;
   base::debug::Alias(&other);
   base::debug::Alias(&creation_stack_);
   CHECK(false);  // CloseHandle called on tracked handle.
 }
 
 }  // namespace
 
 void* GetHandleVerifier() {
-  return g_active_verifier;
+  return ActiveVerifier::Get();
 }
 
 namespace base {
 namespace win {
 
 // Static.
 bool HandleTraits::CloseHandle(HANDLE handle) {
   return ActiveVerifier::Get()->CloseHandle(handle);
 }
 
@@ skipping 12 matching lines @@
 void DisableHandleVerifier() {
   return ActiveVerifier::Get()->Disable();
 }
 
 void OnHandleBeingClosed(HANDLE handle) {
   return ActiveVerifier::Get()->OnHandleBeingClosed(handle);
 }
 
 }  // namespace win
 }  // namespace base