Change MessagePumpForGpu and SharedMemory to ScopedHandle

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 122 matching lines @@
 
 SharedMemoryCreateOptions::SharedMemoryCreateOptions()
     : name_deprecated(nullptr),
       open_existing_deprecated(false),
       size(0),
       executable(false),
       share_read_only(false) {}
 
 SharedMemory::SharedMemory()
     : external_section_(false),
-      mapped_file_(NULL),
       mapped_size_(0),
       memory_(NULL),
       read_only_(false),
       requested_size_(0) {}
 
 SharedMemory::SharedMemory(const std::wstring& name)
     : external_section_(false),
       name_(name),
-      mapped_file_(NULL),
       mapped_size_(0),
       memory_(NULL),
       read_only_(false),
       requested_size_(0) {}
 
 SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
     : external_section_(true),
-      mapped_file_(handle.GetHandle()),
       mapped_size_(0),
       memory_(NULL),
       read_only_(read_only),
       requested_size_(0) {
   DCHECK(!handle.IsValid() || handle.BelongsToCurrentProcess());
+  mapped_file_.Set(handle.GetHandle());
 }
 
 SharedMemory::~SharedMemory() {
   Unmap();
   Close();
 }
 
 // static
 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
   return handle.IsValid();
@@ skipping 35 matching lines @@
 
 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;
   DCHECK(!options.executable);
-  DCHECK(!mapped_file_);
+  DCHECK(!mapped_file_.Get());
   if (options.size == 0) {
     LogError(SIZE_ZERO);
     return false;
   }
 
   // Check maximum accounting for overflow.
   if (options.size >
       static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask) {
     LogError(SIZE_TOO_LARGE);
     return false;
@@ skipping 23 matching lines @@
     }
 
     // Windows ignores DACLs on certain unnamed objects (like shared sections).
     // So, we generate a random name when we need to enforce read-only.
     uint64_t rand_values[4];
     RandBytes(&rand_values, sizeof(rand_values));
     name_ = StringPrintf(L"CrSharedMem_%016llx%016llx%016llx%016llx",
                          rand_values[0], rand_values[1],
                          rand_values[2], rand_values[3]);
   }
-  mapped_file_ = CreateFileMappingWithReducedPermissions(
-      &sa, rounded_size, name_.empty() ? nullptr : name_.c_str());
-  if (!mapped_file_) {
+  mapped_file_.Set(CreateFileMappingWithReducedPermissions(
+      &sa, rounded_size, name_.empty() ? nullptr : name_.c_str()));
+  if (!mapped_file_.IsValid()) {
     // The error is logged within CreateFileMappingWithReducedPermissions().
     return false;
   }
 
   requested_size_ = options.size;
 
   // Check if the shared memory pre-exists.
   if (GetLastError() == ERROR_ALREADY_EXISTS) {
     // If the file already existed, set requested_size_ to 0 to show that
     // we don't know the size.
     requested_size_ = 0;
     external_section_ = true;
     if (!options.open_existing_deprecated) {
       Close();
       LogError(ALREADY_EXISTS);
       return false;
     }
   }
 
   LogError(SUCCESS);
   return true;
 }
 
 bool SharedMemory::Delete(const std::string& name) {
   // intentionally empty -- there is nothing for us to do on Windows.
   return true;
 }
 
 bool SharedMemory::Open(const std::string& name, bool read_only) {
-  DCHECK(!mapped_file_);
+  DCHECK(!mapped_file_.Get());
   DWORD access = FILE_MAP_READ | SECTION_QUERY;
   if (!read_only)
     access |= FILE_MAP_WRITE;
   name_ = ASCIIToUTF16(name);
   read_only_ = read_only;
-  mapped_file_ =
-      OpenFileMapping(access, false, name_.empty() ? nullptr : name_.c_str());
-  if (!mapped_file_)
+  mapped_file_.Set(
+      OpenFileMapping(access, false, name_.empty() ? nullptr : name_.c_str()));
+  if (!mapped_file_.IsValid())
     return false;
   // If a name specified assume it's an external section.
   if (!name_.empty())
     external_section_ = true;
   // Note: size_ is not set in this case.
   return true;
 }
 
 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (mapped_file_ == NULL)
+  if (!mapped_file_.Get())
     return false;
 
   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
     return false;
 
   if (memory_)
     return false;
 
-  if (external_section_ && !IsSectionSafeToMap(mapped_file_))
+  if (external_section_ && !IsSectionSafeToMap(mapped_file_.Get()))
     return false;
 
   memory_ = MapViewOfFile(
-      mapped_file_, read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE,
+      mapped_file_.Get(),
+      read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE,
       static_cast<uint64_t>(offset) >> 32, static_cast<DWORD>(offset), bytes);
   if (memory_ != NULL) {
     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
     mapped_size_ = GetMemorySectionSize(memory_);
     return true;
   }
   return false;
 }
 
 bool SharedMemory::Unmap() {
   if (memory_ == NULL)
     return false;
 
   UnmapViewOfFile(memory_);
   memory_ = NULL;
   return true;
 }
 
 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
                                         SharedMemoryHandle* new_handle,
                                         bool close_self,
                                         ShareMode share_mode) {
   *new_handle = SharedMemoryHandle();
   DWORD access = FILE_MAP_READ | SECTION_QUERY;
   DWORD options = 0;
-  HANDLE mapped_file = mapped_file_;
+  HANDLE mapped_file = mapped_file_.Get();
   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;
+    HANDLE detached_handle = mapped_file_.Take();
+    DCHECK_EQ(detached_handle, mapped_file);
     Unmap();
   }
 
   if (process == GetCurrentProcess() && close_self) {
     *new_handle = SharedMemoryHandle(mapped_file, base::GetCurrentProcId());
     return true;
   }
 
   if (!::DuplicateHandle(GetCurrentProcess(), mapped_file, process, &result,
                          access, FALSE, options)) {
     return false;
   }
   *new_handle = SharedMemoryHandle(result, base::GetProcId(process));
   new_handle->SetOwnershipPassesToIPC(true);
   return true;
 }
 
 
 void SharedMemory::Close() {
-  if (mapped_file_ != NULL) {
-    ::CloseHandle(mapped_file_);
-    mapped_file_ = NULL;
-  }
+  mapped_file_.Close();
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
-  return SharedMemoryHandle(mapped_file_, base::GetCurrentProcId());
+  return SharedMemoryHandle(mapped_file_.Get(), base::GetCurrentProcId());
 }
 
 }  // namespace base