Use std::atomic instead of atopmicops.h in PartitionAlloc.

base/allocator/partition_allocator/page_allocator.cc

 // Copyright (c) 2013 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/allocator/partition_allocator/page_allocator.h"
 
 #include <limits.h>
 
+#include <atomic>
+
 #include "base/allocator/partition_allocator/address_space_randomization.h"
-#include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 
 #include <errno.h>
 #include <sys/mman.h>
 
 #ifndef MADV_FREE
 #define MADV_FREE MADV_DONTNEED
 #endif
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 
 // On POSIX |mmap| uses a nearby address if the hint address is blocked.
 static const bool kHintIsAdvisory = true;
-static volatile base::subtle::Atomic32 s_allocPageErrorCode = 0;
+static std::atomic<int32_t> s_allocPageErrorCode{0};
 
 #elif defined(OS_WIN)
 
 #include <windows.h>
 
 // |VirtualAlloc| will fail if allocation at the hint address is blocked.
 static const bool kHintIsAdvisory = false;
-static base::subtle::Atomic32 s_allocPageErrorCode = ERROR_SUCCESS;
+static std::atomic<int32_t> s_allocPageErrorCode{ERROR_SUCCESS};
 
 #else
 #error Unknown OS
 #endif  // defined(OS_POSIX)
 
 namespace base {
 
 // This internal function wraps the OS-specific page allocation call:
 // |VirtualAlloc| on Windows, and |mmap| on POSIX.
 static void* SystemAllocPages(
     void* hint,
     size_t length,
     PageAccessibilityConfiguration page_accessibility) {
   DCHECK(!(length & kPageAllocationGranularityOffsetMask));
   DCHECK(!(reinterpret_cast<uintptr_t>(hint) &
            kPageAllocationGranularityOffsetMask));
   void* ret;
 #if defined(OS_WIN)
   DWORD access_flag =
       page_accessibility == PageAccessible ? PAGE_READWRITE : PAGE_NOACCESS;
   ret = VirtualAlloc(hint, length, MEM_RESERVE | MEM_COMMIT, access_flag);
   if (!ret)
-    base::subtle::Release_Store(&s_allocPageErrorCode, GetLastError());
+    s_allocPageErrorCode = GetLastError();
 #else
   int access_flag = page_accessibility == PageAccessible
                         ? (PROT_READ | PROT_WRITE)
                         : PROT_NONE;
   ret = mmap(hint, length, access_flag, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   if (ret == MAP_FAILED) {
-    base::subtle::Release_Store(&s_allocPageErrorCode, errno);
+    s_allocPageErrorCode = errno;
     ret = 0;
   }
 #endif
   return ret;
 }
 
 // Trims base to given length and alignment. Windows returns null on failure and
 // frees base.
 static void* TrimMapping(void* base,
                          size_t base_length,
@@ skipping 186 matching lines @@
   // DiscardVirtualMemory is buggy in Win10 SP0, so fall back to MEM_RESET on
   // failure.
   if (ret) {
     void* ret = VirtualAlloc(address, length, MEM_RESET, PAGE_READWRITE);
     CHECK(ret);
   }
 #endif
 }
 
 uint32_t GetAllocPageErrorCode() {
-  return base::subtle::Acquire_Load(&s_allocPageErrorCode);
+  return s_allocPageErrorCode;
 }
 
 }  // namespace base