Base: Add a handle verifier to ScopedHandle.

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 <map>
+#include <set>
+
+#include "base/debug/alias.h"
+#include "base/lazy_instance.h"
+#include "base/synchronization/lock.h"
+#include "base/win/windows_version.h"
+
+namespace {
+
+struct Info {
+  const void* owner;
+  const void* pc;
+  DWORD thread_id;
+};
+typedef std::map<HANDLE, Info> HandleMap;
+
+base::LazyInstance<HandleMap> g_handle_map = LAZY_INSTANCE_INITIALIZER;

[willchan no longer on Chromium, 2012/05/31 03:01:25]

Perhaps you should use a leaky lazy instance? Does this ever get used on a
thread that's not joined at shutdown? Actually wait, isn't that the problem at
hand? I think it'll be safer to use base::LazyInstance<T>::Leaky.

+base::LazyInstance<std::set<const void*> > g_owner_set =
+    LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<base::Lock> g_lock = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+namespace base {
+namespace win {
+
+// Static.
+void VerifierTraits::StartTracking(HANDLE handle, const void* owner,
+                                   const void* pc) {
+  if (OSInfo::GetInstance()->version() > VERSION_XP)
+    return;
+
+  // Grab the thread id before the lock.
+  DWORD thread_id = GetCurrentThreadId();
+
+  AutoLock(g_lock.Get());
+
+  if (handle == INVALID_HANDLE_VALUE) {
+    // Cannot track this handle.
+    g_owner_set.Get().insert(owner);
+    return;
+  }
+
+  Info handle_info = { owner, pc, thread_id };
+  std::pair<HANDLE, Info> item(handle, handle_info);
+  std::pair<HandleMap::iterator, bool> result = g_handle_map.Get().insert(item);
+  if (!result.second) {
+    Info other = result.first->second;
+    debug::Alias(&other);
+    CHECK(false);
+  }
+}
+
+// Static.
+void VerifierTraits::StopTracking(HANDLE handle, const void* owner,
+                                  const void* pc) {
+  if (OSInfo::GetInstance()->version() > VERSION_XP)
+    return;
+
+  AutoLock(g_lock.Get());
+  HandleMap::iterator i = g_handle_map.Get().find(handle);
+  if (i == g_handle_map.Get().end()) {
+    std::set<const void*>::iterator j = g_owner_set.Get().find(owner);
+    if (j != g_owner_set.Get().end()) {
+      g_owner_set.Get().erase(j);
+      return;
+    }
+    CHECK(false);
+  }
+
+  Info other = i->second;
+  if (other.owner != owner) {
+    debug::Alias(&other);
+    CHECK(false);
+  }
+
+  g_handle_map.Get().erase(i);
+}
+
+}  // namespace win
+}  // namespace base