ScopedProcessInformation protects against process/thread handle leaks from CreateProcess calls.

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>
 
@@ skipping 23 matching lines @@
 
   ~GenericScopedHandle() {
     Close();
   }
 
   bool IsValid() const {
     return Traits::IsHandleValid(handle_);
   }
 
   void Set(Handle handle) {
-    if (handle_ != handle) {
+    if (!Traits::IsSame(handle_, handle)) {
       Close();
 
       if (Traits::IsHandleValid(handle)) {
         handle_ = handle;
       }
     }
   }
 
   Handle Get() const {
     return handle_;
@@ skipping 39 matching lines @@
   // Closes the handle.
   static bool CloseHandle(HANDLE handle) {
     return ::CloseHandle(handle) != FALSE;
   }
 
   // Returns true if the handle value is valid.
   static bool IsHandleValid(HANDLE handle) {
     return handle != NULL && handle != INVALID_HANDLE_VALUE;
   }
 
+  // Returns true if the handle values are the same.
+  static bool IsSame(HANDLE lhs, HANDLE rhs) {

[alexeypa (please no reviews), 2012/03/15 02:41:31]

We will be able to avoid changing all instances of handle traits classes when
making similar changes in the future if we define a base traits class. It should
implement the methods that are usually copy-pasted. Something like this:


template <class T>
class BaseHandleTraits {
 public:
  typedef T Handle;

  // Returns true if the handle value is valid.
  bool IsHandleValid(const T& handle) const {
    return handle != NullHandle();
  }

  bool IsSame(const T& left, const T& right) const {
    return left == right;
  }

  // Returns NULL handle value.
  T NullHandle() const {
    return NULL;
  }
};

class HandleTraits : public BaseHandleTraits<HANDLE> {
 public:

  // Closes the handle.
  bool CloseHandle(HANDLE handle) const {
    return ::CloseHandle(handle) != FALSE;
  }
};

GenericScopedHandle will need to be changed to use non-static methods of the
traits class, which should not be a problem.

[erikwright (departed), 2012/03/15 03:29:17]

I thought about listing this as one of my proposed minor changes. I decided
against it after noting that HandleTraits would only actually use two of these
methods (IsSame and NullHandle).

Another option would be to use a bit of template magic here to use == unless
base::is_class<Handle>
(http://code.google.com/codesearch#OAMlx_jo-ck/src/base/template_util.h&exact_...)
in which case an IsSame method must be provided.

+    return lhs == rhs;
+  }
+
   // Returns NULL handle value.
   static HANDLE NullHandle() {
     return NULL;
   }
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(HandleTraits);
 };
 
 typedef GenericScopedHandle<HandleTraits> ScopedHandle;
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_SCOPED_HANDLE_WIN_H_