Make SharedMemoryHandle a class on windows.

base/memory/shared_memory_win.cc

 // Copyright (c) 2011 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.h"
 
 #include <aclapi.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 27 matching lines @@
 SharedMemory::SharedMemory(const std::wstring& name)
     : name_(name),
       mapped_file_(NULL),
       mapped_size_(0),
       memory_(NULL),
       read_only_(false),
       requested_size_(0) {
 }
 
 SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
-    : mapped_file_(handle),
+    : mapped_file_(handle.GetHandle()),
       mapped_size_(0),
       memory_(NULL),
       read_only_(read_only),
       requested_size_(0) {
+  DCHECK(!handle.IsValid() || handle.BelongsToCurrentProcess());
 }
 
 SharedMemory::SharedMemory(const SharedMemoryHandle& handle,
                            bool read_only,
                            ProcessHandle process)
     : mapped_file_(NULL),
       mapped_size_(0),
       memory_(NULL),
       read_only_(read_only),
       requested_size_(0) {
-  ::DuplicateHandle(process, handle,
-                    GetCurrentProcess(), &mapped_file_,
-                    read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
-                        FILE_MAP_WRITE,
-                    FALSE, 0);
+  ::DuplicateHandle(
+      process, handle.GetHandle(), GetCurrentProcess(), &mapped_file_,
+      read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE, FALSE, 0);
 }
 
 SharedMemory::~SharedMemory() {
   Unmap();
   Close();
 }
 
 // static
 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle != NULL;
+  return handle.IsValid();
 }
 
 // static
 SharedMemoryHandle SharedMemory::NULLHandle() {
-  return NULL;
+  return SharedMemoryHandle();
 }
 
 // static
 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  DCHECK(handle != NULL);
-  ::CloseHandle(handle);
+  handle.Close();
 }
 
 // static
 size_t SharedMemory::GetHandleLimit() {
   // Rounded down from value reported here:
   // http://blogs.technet.com/b/markrussinovich/archive/2009/09/29/3283844.aspx
   return static_cast<size_t>(1 << 23);
 }
 
 // static
 SharedMemoryHandle SharedMemory::DuplicateHandle(
     const SharedMemoryHandle& handle) {
+  DCHECK(handle.BelongsToCurrentProcess());
+  HANDLE duped_handle;
   ProcessHandle process = GetCurrentProcess();
-  SharedMemoryHandle duped_handle;
-  BOOL success = ::DuplicateHandle(process, handle, process, &duped_handle, 0,
-                                   FALSE, DUPLICATE_SAME_ACCESS);
+  BOOL success =
+      ::DuplicateHandle(process, handle.GetHandle(), process, &duped_handle, 0,
+                        FALSE, DUPLICATE_SAME_ACCESS);
   if (success)
-    return duped_handle;
-  return NULLHandle();
+    return SharedMemoryHandle(duped_handle, GetCurrentProcId());
+  return SharedMemoryHandle();
 }
 
 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
   return CreateAnonymous(size) && Map(size);
 }
 
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
   // TODO(bsy,sehr): crbug.com/210609 NaCl forces us to round up 64k here,
   // wasting 32k per mapping on average.
   static const size_t kSectionMask = 65536 - 1;
@@ skipping 105 matching lines @@
 
   UnmapViewOfFile(memory_);
   memory_ = NULL;
   return true;
 }
 
 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
                                         SharedMemoryHandle* new_handle,
                                         bool close_self,
                                         ShareMode share_mode) {
-  *new_handle = 0;
+  *new_handle = SharedMemoryHandle();
   DWORD access = FILE_MAP_READ;
   DWORD options = 0;
   HANDLE mapped_file = mapped_file_;
   HANDLE result;
   if (share_mode == SHARE_CURRENT_MODE && !read_only_)
     access |= FILE_MAP_WRITE;
   if (close_self) {
     // DUPLICATE_CLOSE_SOURCE causes DuplicateHandle to close mapped_file.
     options = DUPLICATE_CLOSE_SOURCE;
     mapped_file_ = NULL;
     Unmap();
   }
 
   if (process == GetCurrentProcess() && close_self) {
-    *new_handle = mapped_file;
+    *new_handle = SharedMemoryHandle(mapped_file, base::GetCurrentProcId());
     return true;
   }
 
   if (!::DuplicateHandle(GetCurrentProcess(), mapped_file, process, &result,
                          access, FALSE, options)) {
     return false;
   }
-  *new_handle = result;
+  *new_handle = SharedMemoryHandle(result, base::GetProcId(process));
   return true;
 }
 
 
 void SharedMemory::Close() {
   if (mapped_file_ != NULL) {
-    CloseHandle(mapped_file_);
+    ::CloseHandle(mapped_file_);
     mapped_file_ = NULL;
   }
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
-  return mapped_file_;
+  return SharedMemoryHandle(mapped_file_, base::GetCurrentProcId());
 }
 
 }  // namespace base