Deleted OS_WIN and all Windows specific files from base.

base/memory/shared_memory_win.cc

Index: base/memory/shared_memory_win.cc
diff --git a/base/memory/shared_memory_win.cc b/base/memory/shared_memory_win.cc
deleted file mode 100644
index eacf0d6ccefcd97bd42d6758d4c99597d41f1730..0000000000000000000000000000000000000000
--- a/base/memory/shared_memory_win.cc
+++ /dev/null
@@ -1,297 +0,0 @@
-// 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"
-#include "base/rand_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-
-namespace {
-
-// Returns the length of the memory section starting at the supplied address.
-size_t GetMemorySectionSize(void* address) {
-  MEMORY_BASIC_INFORMATION memory_info;
-  if (!::VirtualQuery(address, &memory_info, sizeof(memory_info)))
-    return 0;
-  return memory_info.RegionSize - (static_cast<char*>(address) -
-         static_cast<char*>(memory_info.AllocationBase));
-}
-
-}  // namespace.
-
-namespace base {
-
-SharedMemory::SharedMemory()
-    : mapped_file_(NULL),
-      memory_(NULL),
-      read_only_(false),
-      mapped_size_(0),
-      requested_size_(0),
-      lock_(NULL) {
-}
-
-SharedMemory::SharedMemory(const std::wstring& name)
-    : mapped_file_(NULL),
-      memory_(NULL),
-      read_only_(false),
-      requested_size_(0),
-      mapped_size_(0),
-      lock_(NULL),
-      name_(name) {
-}
-
-SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
-    : mapped_file_(handle),
-      memory_(NULL),
-      read_only_(read_only),
-      requested_size_(0),
-      mapped_size_(0),
-      lock_(NULL) {
-}
-
-SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
-                           ProcessHandle process)
-    : mapped_file_(NULL),
-      memory_(NULL),
-      read_only_(read_only),
-      requested_size_(0),
-      mapped_size_(0),
-      lock_(NULL) {
-  ::DuplicateHandle(process, handle,
-                    GetCurrentProcess(), &mapped_file_,
-                    read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
-                        FILE_MAP_WRITE,
-                    FALSE, 0);
-}
-
-SharedMemory::~SharedMemory() {
-  Unmap();
-  Close();
-  if (lock_ != NULL)
-    CloseHandle(lock_);
-}
-
-// static
-bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle != NULL;
-}
-
-// static
-SharedMemoryHandle SharedMemory::NULLHandle() {
-  return NULL;
-}
-
-// static
-void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  DCHECK(handle != NULL);
-  ::CloseHandle(handle);
-}
-
-// 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) {
-  ProcessHandle process = GetCurrentProcess();
-  SharedMemoryHandle duped_handle;
-  BOOL success = ::DuplicateHandle(process, handle, process, &duped_handle, 0,
-                                   FALSE, DUPLICATE_SAME_ACCESS);
-  if (success)
-    return duped_handle;
-  return NULLHandle();
-}
-
-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_);
-  if (options.size == 0)
-    return false;
-
-  // Check maximum accounting for overflow.
-  if (options.size >
-      static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask)
-    return false;
-
-  size_t rounded_size = (options.size + kSectionMask) & ~kSectionMask;
-  name_ = options.name_deprecated ?
-      ASCIIToUTF16(*options.name_deprecated) : L"";
-  SECURITY_ATTRIBUTES sa = { sizeof(sa), NULL, FALSE };
-  SECURITY_DESCRIPTOR sd;
-  ACL dacl;
-
-  if (options.share_read_only && name_.empty()) {
-    // Add an empty DACL to enforce anonymous read-only sections.
-    sa.lpSecurityDescriptor = &sd;
-    if (!InitializeAcl(&dacl, sizeof(dacl), ACL_REVISION))
-      return false;
-    if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION))
-      return false;
-    if (!SetSecurityDescriptorDacl(&sd, TRUE, &dacl, FALSE))
-      return false;
-
-    // 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_%016x%016x%016x%016x",
-                         rand_values[0], rand_values[1],
-                         rand_values[2], rand_values[3]);
-  }
-  mapped_file_ = CreateFileMapping(INVALID_HANDLE_VALUE, &sa,
-      PAGE_READWRITE, 0, static_cast<DWORD>(rounded_size),
-      name_.empty() ? nullptr : name_.c_str());
-  if (!mapped_file_)
-    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;
-    if (!options.open_existing_deprecated) {
-      Close();
-      return false;
-    }
-  }
-
-  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_);
-
-  name_ = ASCIIToUTF16(name);
-  read_only_ = read_only;
-  mapped_file_ = OpenFileMapping(
-      read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE,
-      false, name_.empty() ? NULL : name_.c_str());
-  if (mapped_file_ != NULL) {
-    // Note: size_ is not set in this case.
-    return true;
-  }
-  return false;
-}
-
-bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (mapped_file_ == NULL)
-    return false;
-
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-
-  if (memory_)
-    return false;
-
-  memory_ = MapViewOfFile(mapped_file_,
-                          read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
-                              FILE_MAP_WRITE,
-                          static_cast<uint64>(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 = 0;
-  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;
-    return true;
-  }
-
-  if (!::DuplicateHandle(GetCurrentProcess(), mapped_file, process, &result,
-                         access, FALSE, options)) {
-    return false;
-  }
-  *new_handle = result;
-  return true;
-}
-
-
-void SharedMemory::Close() {
-  if (mapped_file_ != NULL) {
-    CloseHandle(mapped_file_);
-    mapped_file_ = NULL;
-  }
-}
-
-void SharedMemory::LockDeprecated() {
-  if (lock_ == NULL) {
-    std::wstring name = name_;
-    name.append(L"lock");
-    lock_ = CreateMutex(NULL, FALSE, name.c_str());
-    if (lock_ == NULL) {
-      DPLOG(ERROR) << "Could not create mutex.";
-      NOTREACHED();
-      return;  // There is nothing good we can do here.
-    }
-  }
-  DWORD result = WaitForSingleObject(lock_, INFINITE);
-  DCHECK_EQ(result, WAIT_OBJECT_0);
-}
-
-void SharedMemory::UnlockDeprecated() {
-  DCHECK(lock_ != NULL);
-  ReleaseMutex(lock_);
-}
-
-SharedMemoryHandle SharedMemory::handle() const {
-  return mapped_file_;
-}
-
-}  // namespace base