Base: Add a handle verifier to ScopedHandle.

base/win/scoped_handle.h

 // 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.
 
 #ifndef BASE_WIN_SCOPED_HANDLE_H_
 #define BASE_WIN_SCOPED_HANDLE_H_
 #pragma once
 
 #include <windows.h>
 
+#include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/location.h"
 #include "base/logging.h"
 
 namespace base {
 namespace win {
 
 // Generic wrapper for raw handles that takes care of closing handles
 // automatically. The class interface follows the style of
 // the ScopedStdioHandle class with a few additions:
 //   - IsValid() method can tolerate multiple invalid handle values such as NULL
 //     and INVALID_HANDLE_VALUE (-1) for Win32 handles.
 //   - Receive() method allows to receive a handle value from a function that
 //     takes a raw handle pointer only.
-template <class Traits>
+template <class Traits, class Verifier>
 class GenericScopedHandle {
  public:
   typedef typename Traits::Handle Handle;
 
   GenericScopedHandle() : handle_(Traits::NullHandle()) {}
 
   explicit GenericScopedHandle(Handle handle) : handle_(Traits::NullHandle()) {
     Set(handle);
   }
 
   ~GenericScopedHandle() {
     Close();
   }
 
   bool IsValid() const {
     return Traits::IsHandleValid(handle_);
   }
 
   void Set(Handle handle) {
     if (handle_ != handle) {
       Close();
 
       if (Traits::IsHandleValid(handle)) {
         handle_ = handle;
+        Verifier::StartTracking(handle, this,
+                                tracked_objects::GetProgramCounter());
       }
     }
   }
 
   Handle Get() const {
     return handle_;
   }
 
   operator Handle() const {
     return handle_;
   }
 
   Handle* Receive() {
     DCHECK(!Traits::IsHandleValid(handle_)) << "Handle must be NULL";
+
+    // We cannot track this case :(. Just tell the verifier about it.

[alexeypa (please no reviews), 2012/05/30 20:19:30]

This is one of the most common ways of initializing GenericScopedHandle objects.

[rvargas (doing something else), 2012/05/30 21:39:01]

That is both unfortunate and surprising (given that this method was added three
months ago). I'm all ears if you have ideas for tracking this (short of removing
the method and changing callers to use a temp).

+    Verifier::StartTracking(INVALID_HANDLE_VALUE, this,
+                            tracked_objects::GetProgramCounter());
     return &handle_;
   }
 
   // Transfers ownership away from this object.
   Handle Take() {
     Handle temp = handle_;
     handle_ = Traits::NullHandle();
+    Verifier::StopTracking(temp, this, tracked_objects::GetProgramCounter());
     return temp;
   }
 
   // Explicitly closes the owned handle.
   void Close() {
     if (Traits::IsHandleValid(handle_)) {
       if (!Traits::CloseHandle(handle_)) {
         CHECK(false);
       }
+      Verifier::StopTracking(handle_, this,
+                             tracked_objects::GetProgramCounter());
       handle_ = Traits::NullHandle();
     }
   }
 
  private:
   Handle handle_;
 
   DISALLOW_COPY_AND_ASSIGN(GenericScopedHandle);
 };
 
@@ skipping 14 matching lines @@
 
   // Returns NULL handle value.
   static HANDLE NullHandle() {
     return NULL;
   }
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(HandleTraits);
 };
 
-typedef GenericScopedHandle<HandleTraits> ScopedHandle;
+// Do-nothing verifier.
+class DummyVerifierTraits {
+ public:
+  typedef HANDLE Handle;
+
+  static void StartTracking(HANDLE handle, const void* owner, const void* pc) {}
+  static void StopTracking(HANDLE handle, const void* owner, const void* pc) {}
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(DummyVerifierTraits);
+};
+
+// Performs actual run-time tracking.
+class BASE_EXPORT VerifierTraits {
+ public:
+  typedef HANDLE Handle;
+
+  static void StartTracking(HANDLE handle, const void* owner, const void* pc);
+  static void StopTracking(HANDLE handle, const void* owner, const void* pc);
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(VerifierTraits);
+};
+
+typedef GenericScopedHandle<HandleTraits, DummyVerifierTraits> ScopedHandle;
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_SCOPED_HANDLE_WIN_H_