The Tor Browser: comparison security/sandbox/chromium/base/win/scoped

--1:000000000000
+:b20317274eb5
+// 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_
+#include <windows.h>
+#include "base/base_export.h"
+#include "base/basictypes.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/move.h"
+namespace base {
+namespace win {
+// TODO(rvargas): remove this with the rest of the verifier.
+#if defined(COMPILER_MSVC)
+// MSDN says to #include <intrin.h>, but that breaks the VS2005 build.
+extern "C" {
+void* _ReturnAddress();
+}
+#define BASE_WIN_GET_CALLER _ReturnAddress()
+#elif defined(COMPILER_GCC)
+#define BASE_WIN_GET_CALLER __builtin_extract_return_addr(\\
+__builtin_return_address(0))
+#endif
+// 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, class Verifier>
+class GenericScopedHandle {
+MOVE_ONLY_TYPE_FOR_CPP_03(GenericScopedHandle, RValue)
+public:
+typedef typename Traits::Handle Handle;
+// Helper object to contain the effect of Receive() to the function that needs
+// a pointer, and allow proper tracking of the handle.
+class Receiver {
+public:
+explicit Receiver(GenericScopedHandle* owner)
+: handle_(Traits::NullHandle()),
+owner_(owner) {}
+~Receiver() { owner_->Set(handle_); }
+operator Handle*() { return &handle_; }
+private:
+Handle handle_;
+GenericScopedHandle* owner_;
+};
+GenericScopedHandle() : handle_(Traits::NullHandle()) {}
+explicit GenericScopedHandle(Handle handle) : handle_(Traits::NullHandle()) {
+Set(handle);
+}
+// Move constructor for C++03 move emulation of this type.
+GenericScopedHandle(RValue other) : handle_(Traits::NullHandle()) {
+Set(other.object->Take());
+}
+~GenericScopedHandle() {
+Close();
+}
+bool IsValid() const {
+return Traits::IsHandleValid(handle_);
+}
+// Move operator= for C++03 move emulation of this type.
+GenericScopedHandle& operator=(RValue other) {
+if (this != other.object) {
+Set(other.object->Take());
+}
+return *this;
+}
+void Set(Handle handle) {
+if (handle_ != handle) {
+Close();
+if (Traits::IsHandleValid(handle)) {
+handle_ = handle;
+Verifier::StartTracking(handle, this, BASE_WIN_GET_CALLER,
+tracked_objects::GetProgramCounter());
+}
+}
+}
+Handle Get() const {
+return handle_;
+}
+operator Handle() const {
+return handle_;
+}
+// This method is intended to be used with functions that require a pointer to
+// a destination handle, like so:
+//    void CreateRequiredHandle(Handle* out_handle);
+//    ScopedHandle a;
+//    CreateRequiredHandle(a.Receive());
+Receiver Receive() {
+DCHECK(!Traits::IsHandleValid(handle_)) << "Handle must be NULL";
+return Receiver(this);
+}
+// Transfers ownership away from this object.
+Handle Take() {
+Handle temp = handle_;
+handle_ = Traits::NullHandle();
+if (Traits::IsHandleValid(temp)) {
+Verifier::StopTracking(temp, this, BASE_WIN_GET_CALLER,
+tracked_objects::GetProgramCounter());
+}
+return temp;
+}
+// Explicitly closes the owned handle.
+void Close() {
+if (Traits::IsHandleValid(handle_)) {
+Verifier::StopTracking(handle_, this, BASE_WIN_GET_CALLER,
+tracked_objects::GetProgramCounter());
+if (!Traits::CloseHandle(handle_))
+CHECK(false);
+handle_ = Traits::NullHandle();
+}
+}
+private:
+Handle handle_;
+};
+#undef BASE_WIN_GET_CALLER
+// The traits class for Win32 handles that can be closed via CloseHandle() API.
+class HandleTraits {
+public:
+typedef HANDLE Handle;
+// 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 NULL handle value.
+static HANDLE NullHandle() {
+return NULL;
+}
+private:
+DISALLOW_IMPLICIT_CONSTRUCTORS(HandleTraits);
+};
+// Do-nothing verifier.
+class DummyVerifierTraits {
+public:
+typedef HANDLE Handle;
+static void StartTracking(HANDLE handle, const void* owner,
+const void* pc1, const void* pc2) {}
+static void StopTracking(HANDLE handle, const void* owner,
+const void* pc1, const void* pc2) {}
+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* pc1, const void* pc2);
+static void StopTracking(HANDLE handle, const void* owner,
+const void* pc1, const void* pc2);
+private:
+DISALLOW_IMPLICIT_CONSTRUCTORS(VerifierTraits);
+};
+typedef GenericScopedHandle<HandleTraits, VerifierTraits> ScopedHandle;
+}  // namespace win
+}  // namespace base
+#endif  // BASE_SCOPED_HANDLE_WIN_H_

The Tor Browser / file comparison

comparison: security/sandbox/chromium/base/win/scoped_handle.h

security/sandbox/chromium/base/win/scoped_handle.h