Add test for multithreaded ActiveVerifier behavior.

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>
 
 #include "base/debug/alias.h"
 #include "base/debug/stack_trace.h"
 #include "base/hash.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/process/memory.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/threading/thread_local.h"
 
 extern "C" {
 __declspec(dllexport) void* GetHandleVerifier();
 typedef void* (*GetHandleVerifierFn)();
 }
 
 namespace {
 
@@ skipping 51 matching lines @@
   // The methods required by HandleTraits. They are virtual because we need to
   // forward the call execution to another module, instead of letting the
   // compiler call the version that is linked in the current module.
   virtual bool CloseHandle(HANDLE handle);
   virtual void StartTracking(HANDLE handle, const void* owner,
                              const void* pc1, const void* pc2);
   virtual void StopTracking(HANDLE handle, const void* owner,
                             const void* pc1, const void* pc2);
   virtual void Disable();
   virtual void OnHandleBeingClosed(HANDLE handle);
+  virtual bool GetCodeAddress(const void** pc) const;
 
  private:
   ~ActiveVerifier();  // Not implemented.
 
   static void InstallVerifier();
 
   base::debug::StackTrace creation_stack_;
   bool enabled_;
   base::ThreadLocalBoolean closing_;
   NativeLock* lock_;
@@ skipping 137 matching lines @@
   HandleMap::iterator i = map_.find(handle);
   if (i == map_.end())
     return;
 
   Info other = i->second;
   base::debug::Alias(&other);
   base::debug::Alias(&creation_stack_);
   CHECK(false);  // CloseHandle called on tracked handle.
 }
 
+bool ActiveVerifier::GetCodeAddress(const void** pc) const {
+  if (enabled_) {
+    *pc = tracked_objects::GetProgramCounter();
+    return true;
+  }
+
+  return false;
+}
+
 }  // namespace
 
 void* GetHandleVerifier() {
   return ActiveVerifier::Get();
 }
 
 namespace base {
 namespace win {
 
 // Static.
@@ skipping 14 matching lines @@
 }
 
 void DisableHandleVerifier() {
   return ActiveVerifier::Get()->Disable();
 }
 
 void OnHandleBeingClosed(HANDLE handle) {
   return ActiveVerifier::Get()->OnHandleBeingClosed(handle);
 }
 
+HMODULE GetHandleVerifierModuleForTesting() {
+  const void* pc = nullptr;
+
+  bool success = g_active_verifier->GetCodeAddress(&pc);
+  if (success)
+    return base::GetModuleFromAddress(pc);

[scottmg, 2016/03/11 19:02:18]

Can you just use &__ImageBase instead?

.. Oh, I see, it's to make sure you got the right one. OK, just a comment in the
header then describing why we want to do this.

[Will Harris, 2016/03/11 20:35:31]

I've actually changed this to use __ImageBase inside the member function. Much
better.

+
+  return nullptr;
+}
+
 }  // namespace win
 }  // namespace base