Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
// Copyright (c) 2006-2008 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_SCOPED_HANDLE_WIN_H_
#define BASE_SCOPED_HANDLE_WIN_H_
#include <windows.h>
#include "base/basictypes.h"
#include "base/logging.h"
// Used so we always remember to close the handle.
// The class interface matches that of ScopedStdioHandle in addition to an
// IsValid() method since invalid handles on windows can be either NULL or
// INVALID_HANDLE_VALUE (-1).
//
// Example:
// 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 {
public:
ScopedHandle() : handle_(NULL) {}
explicit ScopedHandle(HANDLE h) : handle_(NULL) { Set(h); }
~ScopedHandle() { 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 Take() {
// transfers ownership away from this object
HANDLE h = handle_;
handle_ = NULL;
return h;
}
void Close() {
if (handle_) {
if (!::CloseHandle(handle_)) {
NOTREACHED();
}
handle_ = NULL;
}
}
private:
HANDLE handle_;
DISALLOW_EVIL_CONSTRUCTORS(ScopedHandle);
};
// Like ScopedHandle, but for HANDLEs returned from FindFile().
class ScopedFindFileHandle {
public:
explicit ScopedFindFileHandle(HANDLE handle) : handle_(handle) {
// Windows is inconsistent about invalid handles, so we always use NULL
if (handle_ == INVALID_HANDLE_VALUE) handle_ = NULL;
}
~ScopedFindFileHandle() {
if (handle_) FindClose(handle_);
}
// Use this instead of comparing to INVALID_HANDLE_VALUE to pick up our NULL
// usage for errors.
bool IsValid() const { return handle_ != NULL; }
operator HANDLE() { return handle_; }
private:
HANDLE handle_;
DISALLOW_EVIL_CONSTRUCTORS(ScopedFindFileHandle);
};
// Like ScopedHandle but for HDC. Only use this on HDCs returned from
// CreateCompatibleDC. For an HDC returned by GetDC, use ReleaseDC instead.
class ScopedHDC {
public:
ScopedHDC() : hdc_(NULL) {}
explicit ScopedHDC(HDC h) : hdc_(h) {}
~ScopedHDC() { Close(); }
HDC Get() { return hdc_; }
void Set(HDC h) {
Close();
hdc_ = h;
}
operator HDC() { return hdc_; }
private:
void Close() {
#ifdef NOGDI
assert(false);
#else
if (hdc_) DeleteDC(hdc_);
#endif // NOGDI
}
HDC hdc_;
DISALLOW_EVIL_CONSTRUCTORS(ScopedHDC);
};
// Like ScopedHandle but for GDI objects.
template <class T>
class ScopedGDIObject {
public:
ScopedGDIObject() : object_(NULL) {}
explicit ScopedGDIObject(T object) : object_(object) {}
~ScopedGDIObject() { Close(); }
T Get() { return object_; }
void Set(T object) {
if (object_ && object != object_) Close();
object_ = object;
}
ScopedGDIObject& operator=(T object) {
Set(object);
return *this;
}
operator T() { return object_; }
private:
void Close() {
if (object_) DeleteObject(object_);
}
T object_;
DISALLOW_COPY_AND_ASSIGN(ScopedGDIObject);
};
// Typedefs for some common use cases.
typedef ScopedGDIObject<HBITMAP> ScopedBitmap;
typedef ScopedGDIObject<HRGN> ScopedHRGN;
typedef ScopedGDIObject<HFONT> ScopedHFONT;
// Like ScopedHandle except for HGLOBAL.
template <class T>
class ScopedHGlobal {
public:
explicit ScopedHGlobal(HGLOBAL glob) : glob_(glob) {
data_ = static_cast<T*>(GlobalLock(glob_));
}
~ScopedHGlobal() { GlobalUnlock(glob_); }
T* get() { return data_; }
size_t Size() const { return GlobalSize(glob_); }
T* operator->() const {
assert(data_ != 0);
return data_;
}
private:
HGLOBAL glob_;
T* data_;
DISALLOW_EVIL_CONSTRUCTORS(ScopedHGlobal);
};
#endif // BASE_SCOPED_HANDLE_WIN_H_