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/logging.h"
 #include "base/macros.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/threading/thread_local.h"
 
 extern "C" {
 __declspec(dllexport) void* GetHandleVerifier();
 typedef void* (*GetHandleVerifierFn)();
 }
 
+// http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+
 namespace {
 
 struct HandleHash {
   size_t operator()(const HANDLE& handle) const {
     char buffer[sizeof(handle)];
     memcpy(buffer, &handle, sizeof(handle));
     return base::Hash(buffer, sizeof(buffer));
   }
 };
 
@@ skipping 43 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 void GetModule(HMODULE* module) 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.
 }
 
+void ActiveVerifier::GetModule(HMODULE* module) const {
+  *module = reinterpret_cast<HMODULE>(&__ImageBase);
+}
+
 }  // 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() {
+  HMODULE module = nullptr;
+
+  // Must pass by reference in order to avoid tail-call optimization.

[scottmg, 2016/03/11 22:13:09]

This seems a bit hokey. Would __declspec(noinline) do what you want?

[Will Harris, 2016/03/11 22:23:44]

I needed this when using tracked_objects::GetProgramCounter as it uses
_ReturnAddress. In that case because it was doing a JMP to
tracked_objects::GetProgramCounter the tail call optimization got the wrong
return address, even when using NOINLINE.

But, it's possible __ImageBase doesn't have this issue... although I doubt it
since it's using the same intrinsic calling as _ReturnAddress.

I can certainly try again.

EDIT: oh interesting seem using volatile disables tail call optimization - see
https://code.google.com/p/chromium/codesearch#chromium/src/base/profiler/stac...
maybe that will work too. I'll try several things here.

[Will Harris, 2016/03/11 23:07:47]

I simplified this, seems __ImageBase is less sensitive to tail-call
optimization.

+  g_active_verifier->GetModule(&module);
+
+  return module;
+}
+
 }  // namespace win
 }  // namespace base