src/base/win/scoped_handle.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef BASE_WIN_SCOPED_HANDLE_H_
   6 #define BASE_WIN_SCOPED_HANDLE_H_
   7
   8 #include <windows.h>
   9
  10 #include "base/base_export.h"
  11 #include "base/basictypes.h"
  12 #include "base/location.h"
  13 #include "base/logging.h"
  14 #include "base/move.h"
  15
  16 // TODO(rvargas): remove this with the rest of the verifier.
  17 #if defined(COMPILER_MSVC)
  18 #include <intrin.h>
  19 #define BASE_WIN_GET_CALLER _ReturnAddress()
  20 #elif defined(COMPILER_GCC)
  21 #define BASE_WIN_GET_CALLER __builtin_extract_return_addr(\\
  22     __builtin_return_address(0))
  23 #endif
  24
  25 namespace base {
  26 namespace win {
  27
  28 // Generic wrapper for raw handles that takes care of closing handles
  29 // automatically. The class interface follows the style of
  30 // the ScopedStdioHandle class with one addition:
  31 //   - IsValid() method can tolerate multiple invalid handle values such as NULL
  32 //     and INVALID_HANDLE_VALUE (-1) for Win32 handles.
  33 template <class Traits, class Verifier>
  34 class GenericScopedHandle {
  35   MOVE_ONLY_TYPE_FOR_CPP_03(GenericScopedHandle, RValue)
  36
  37  public:
  38   typedef typename Traits::Handle Handle;
  39
  40   GenericScopedHandle() : handle_(Traits::NullHandle()) {}
  41
  42   explicit GenericScopedHandle(Handle handle) : handle_(Traits::NullHandle()) {
  43     Set(handle);
  44   }
  45
  46   // Move constructor for C++03 move emulation of this type.
  47   GenericScopedHandle(RValue other) : handle_(Traits::NullHandle()) {
  48     Set(other.object->Take());
  49   }
  50
  51   ~GenericScopedHandle() {
  52     Close();
  53   }
  54
  55   bool IsValid() const {
  56     return Traits::IsHandleValid(handle_);
  57   }
  58
  59   // Move operator= for C++03 move emulation of this type.
  60   GenericScopedHandle& operator=(RValue other) {
  61     if (this != other.object) {
  62       Set(other.object->Take());
  63     }
  64     return *this;
  65   }
  66
  67   void Set(Handle handle) {
  68     if (handle_ != handle) {
  69       Close();
  70
  71       if (Traits::IsHandleValid(handle)) {
  72         handle_ = handle;
  73         Verifier::StartTracking(handle, this, BASE_WIN_GET_CALLER,
  74                                 tracked_objects::GetProgramCounter());
  75       }
  76     }
  77   }
  78
  79   Handle Get() const {
  80     return handle_;
  81   }
  82
  83   operator Handle() const {
  84     return handle_;
  85   }
  86
  87   // Transfers ownership away from this object.
  88   Handle Take() {
  89     Handle temp = handle_;
  90     handle_ = Traits::NullHandle();
  91     if (Traits::IsHandleValid(temp)) {
  92       Verifier::StopTracking(temp, this, BASE_WIN_GET_CALLER,
  93                              tracked_objects::GetProgramCounter());
  94     }
  95     return temp;
  96   }
  97
  98   // Explicitly closes the owned handle.
  99   void Close() {
 100     if (Traits::IsHandleValid(handle_)) {
 101       Verifier::StopTracking(handle_, this, BASE_WIN_GET_CALLER,
 102                              tracked_objects::GetProgramCounter());
 103
 104       if (!Traits::CloseHandle(handle_))
 105         CHECK(false);
 106
 107       handle_ = Traits::NullHandle();
 108     }
 109   }
 110
 111  private:
 112   Handle handle_;
 113 };
 114
 115 #undef BASE_WIN_GET_CALLER
 116
 117 // The traits class for Win32 handles that can be closed via CloseHandle() API.
 118 class HandleTraits {
 119  public:
 120   typedef HANDLE Handle;
 121
 122   // Closes the handle.
 123   static bool CloseHandle(HANDLE handle) {
 124     return ::CloseHandle(handle) != FALSE;
 125   }
 126
 127   // Returns true if the handle value is valid.
 128   static bool IsHandleValid(HANDLE handle) {
 129     return handle != NULL && handle != INVALID_HANDLE_VALUE;
 130   }
 131
 132   // Returns NULL handle value.
 133   static HANDLE NullHandle() {
 134     return NULL;
 135   }
 136
 137  private:
 138   DISALLOW_IMPLICIT_CONSTRUCTORS(HandleTraits);
 139 };
 140
 141 // Do-nothing verifier.
 142 class DummyVerifierTraits {
 143  public:
 144   typedef HANDLE Handle;
 145
 146   static void StartTracking(HANDLE handle, const void* owner,
 147                             const void* pc1, const void* pc2) {}
 148   static void StopTracking(HANDLE handle, const void* owner,
 149                            const void* pc1, const void* pc2) {}
 150
 151  private:
 152   DISALLOW_IMPLICIT_CONSTRUCTORS(DummyVerifierTraits);
 153 };
 154
 155 // Performs actual run-time tracking.
 156 class BASE_EXPORT VerifierTraits {
 157  public:
 158   typedef HANDLE Handle;
 159
 160   static void StartTracking(HANDLE handle, const void* owner,
 161                             const void* pc1, const void* pc2);
 162   static void StopTracking(HANDLE handle, const void* owner,
 163                            const void* pc1, const void* pc2);
 164
 165  private:
 166   DISALLOW_IMPLICIT_CONSTRUCTORS(VerifierTraits);
 167 };
 168
 169 typedef GenericScopedHandle<HandleTraits, VerifierTraits> ScopedHandle;
 170
 171 }  // namespace win
 172 }  // namespace base
 173
 174 #endif  // BASE_SCOPED_HANDLE_WIN_H_