Make SharedMemoryHandle a class on windows.

base/memory/shared_memory_handle_win.cc

Index: base/memory/shared_memory_handle_win.cc
diff --git a/base/memory/shared_memory_handle_win.cc b/base/memory/shared_memory_handle_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7d21899434dd9244297e2a88d2201fcbdc343775
--- /dev/null
+++ b/base/memory/shared_memory_handle_win.cc
@@ -0,0 +1,67 @@
+// Copyright 2015 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.
+
+#include "base/memory/shared_memory_handle.h"
+
+#include "base/logging.h"
+
+namespace base {
+
+SharedMemoryHandle::SharedMemoryHandle() : handle_(nullptr), pid_(0) {}

[Nico, 2015/09/24 15:48:54]

(i'm assuming you're aware of
http://blogs.msdn.com/b/oldnewthing/archive/2004/03/02/82639.aspx and that NULL
is the right choice here. looks like it's not an issue in this case from what i
can tell)

[erikchen, 2015/09/24 16:32:42]

Windows is inconsistent about the value it uses to indicate "invalid HANDLE". In
Chrome code we use NULL.

[Nico, 2015/09/24 16:47:43]

The point of the article is that INVALID_HANDLE_VALUE is -1 and NULL is 0 and
that you need to check if the functions you're calling return
INVALID_HANDLE_VALUE or NULL, lest you're checking for the wrong return value.
It's not possible to say "in chrome we use X" as it depends on what the
functions you're calling return. (Each caller to a INVALID_HANDLE_VALUE function
could convert it to NULL and shield the rest of the codebase from this
distinction, maybe that's what you're saying.)

+
+SharedMemoryHandle::SharedMemoryHandle(HANDLE h, base::ProcessId pid)
+    : handle_(h), pid_(pid) {}
+
+SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle)
+    : handle_(handle.handle_), pid_(handle.pid_) {}
+
+SharedMemoryHandle& SharedMemoryHandle::operator=(
+    const SharedMemoryHandle& handle) {
+  if (this == &handle)
+    return *this;
+
+  handle_ = handle.handle_;
+  pid_ = handle.pid_;
+  return *this;
+}
+
+bool SharedMemoryHandle::operator==(const SharedMemoryHandle& handle) const {
+  // Invalid handles are always equal.
+  if (!IsValid() && !handle.IsValid())
+    return true;
+
+  return handle_ == handle.handle_ && pid_ == handle.pid_;
+}
+
+bool SharedMemoryHandle::operator!=(const SharedMemoryHandle& handle) const {
+  return !(*this == handle);
+}
+
+void SharedMemoryHandle::Close() const {
+  DCHECK(handle_ != nullptr);
+  DCHECK(BelongsToCurrentProcess());
+  ::CloseHandle(handle_);
+}
+
+bool SharedMemoryHandle::IsValid() const {
+  return handle_ != nullptr;
+}
+
+bool SharedMemoryHandle::BelongsToCurrentProcess() const {
+  return pid_ == base::GetCurrentProcId();
+}
+
+bool SharedMemoryHandle::NeedsBrokering() const {
+  return false;
+}
+
+HANDLE SharedMemoryHandle::GetHandle() const {
+  return handle_;
+}
+
+base::ProcessId SharedMemoryHandle::GetPID() const {
+  return pid_;
+}
+
+}  // namespace base