Added ScopedPrinterHandle

base/win/scoped_handle.h

 // Copyright (c) 2010 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 12 matching lines @@
 //   ScopedHandle hfile(CreateFile(...));
 //   if (!hfile.Get())
 //     ...process error
 //   ReadFile(hfile.Get(), ...);
 //
 // To sqirrel the handle away somewhere else:
 //   secret_handle_ = hfile.Take();
 //
 // To explicitly close the handle:
 //   hfile.Close();
-class ScopedHandle {
+template <class Traits>
+class GenericScopedHandle {

[alexeypa (please no reviews), 2012/03/01 21:37:43]

Consider implementing it as

template <class T, class Traits>
class GenericScopedHandle {...};

where T is the raw handle type. This will require abstracting NULL handle
concept via Traits.

[Vitaly Buka (NO REVIEWS), 2012/03/01 22:14:42]

I thought about that. But I'd like to add feature when it needed.

On 2012/03/01 21:37:43, alexeypa wrote:

  public:
-  ScopedHandle() : handle_(NULL) {
+  GenericScopedHandle() : handle_(NULL) {
   }
 
-  explicit ScopedHandle(HANDLE h) : handle_(NULL) {
+  explicit GenericScopedHandle(HANDLE h) : handle_(NULL) {
     Set(h);
   }
 
-  ~ScopedHandle() {
+  ~GenericScopedHandle() {
     Close();
   }
 
   // Use this instead of comparing to INVALID_HANDLE_VALUE to pick up our NULL
   // usage for errors.
   bool IsValid() const {
     return handle_ != NULL;
   }
 
   void Set(HANDLE new_handle) {
     Close();
 
     // Windows is inconsistent about invalid handles, so we always use NULL
     if (new_handle != INVALID_HANDLE_VALUE)
       handle_ = new_handle;
   }
 
   HANDLE Get() {
     return handle_;
   }
 
   operator HANDLE() { return handle_; }
 
+  HANDLE* Receive() {
+    DCHECK(!handle_) << "Handle must be NULL";
+    return &handle_;
+  }
+
   HANDLE Take() {
     // transfers ownership away from this object
     HANDLE h = handle_;
     handle_ = NULL;
     return h;
   }
 
   void Close() {
     if (handle_) {
-      if (!::CloseHandle(handle_)) {
+      if (!Traits::CloseHandle(handle_)) {
         NOTREACHED();
       }
       handle_ = NULL;
     }
   }
 
  private:
   HANDLE handle_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedHandle);
+  DISALLOW_COPY_AND_ASSIGN(GenericScopedHandle);
 };
 
+class DefaultHandleTraits {

[alexeypa (please no reviews), 2012/03/01 21:37:43]

Consider renaming it to HandleTraits. It is in a Windows-specific namespace
already, were "handle" means HANDLE. (Win32 HANDLE actually). Other types of
handles usually have some prefix in the name.

[Vitaly Buka (NO REVIEWS), 2012/03/01 22:14:42]

Done.

+ public:
+  static bool CloseHandle(HANDLE handle) {
+    return ::CloseHandle(handle) != FALSE;
+  }
+};
+
+typedef GenericScopedHandle<DefaultHandleTraits> ScopedHandle;
+
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_SCOPED_HANDLE_WIN_H_