Add m-esr52 at 52.6.0

1 files changed, 219 insertions, 0 deletions

diff --git a/ipc/chromium/src/base/scoped_handle_win.h b/ipc/chromium/src/base/scoped_handle_win.h
new file mode 100644
index 000000000..d4d8fccc4
--- /dev/null
+++ b/ipc/chromium/src/base/scoped_handle_win.h
@@ -0,0 +1,219 @@
+/* -*- 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_