Remove atomicops, and some unused bind helpers Change-Id: I8a7ed3547011dd823286bdc056889ab7a9477443 Reviewed-on: https://gn-review.googlesource.com/1623 Commit-Queue: Scott Graham <scottmg@chromium.org> Reviewed-by: Brett Wilson <brettw@chromium.org>
diff --git a/base/atomic_sequence_num.h b/base/atomic_sequence_num.h deleted file mode 100644 index 717e37a..0000000 --- a/base/atomic_sequence_num.h +++ /dev/null
@@ -1,33 +0,0 @@ -// Copyright (c) 2012 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. - -#ifndef BASE_ATOMIC_SEQUENCE_NUM_H_ -#define BASE_ATOMIC_SEQUENCE_NUM_H_ - -#include <atomic> - -#include "base/macros.h" - -namespace base { - -// AtomicSequenceNumber is a thread safe increasing sequence number generator. -// Its constructor doesn't emit a static initializer, so it's safe to use as a -// global variable or static member. -class AtomicSequenceNumber { - public: - constexpr AtomicSequenceNumber() = default; - - // Returns an increasing sequence number starts from 0 for each call. - // This function can be called from any thread without data race. - inline int GetNext() { return seq_.fetch_add(1, std::memory_order_relaxed); } - - private: - std::atomic_int seq_{0}; - - DISALLOW_COPY_AND_ASSIGN(AtomicSequenceNumber); -}; - -} // namespace base - -#endif // BASE_ATOMIC_SEQUENCE_NUM_H_
diff --git a/base/atomicops.h b/base/atomicops.h deleted file mode 100644 index ccf05f9..0000000 --- a/base/atomicops.h +++ /dev/null
@@ -1,161 +0,0 @@ -// Copyright (c) 2012 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. - -// For atomic operations on reference counts, see atomic_refcount.h. -// For atomic operations on sequence numbers, see atomic_sequence_num.h. - -// The routines exported by this module are subtle. If you use them, even if -// you get the code right, it will depend on careful reasoning about atomicity -// and memory ordering; it will be less readable, and harder to maintain. If -// you plan to use these routines, you should have a good reason, such as solid -// evidence that performance would otherwise suffer, or there being no -// alternative. You should assume only properties explicitly guaranteed by the -// specifications in this file. You are almost certainly _not_ writing code -// just for the x86; if you assume x86 semantics, x86 hardware bugs and -// implementations on other archtectures will cause your code to break. If you -// do not know what you are doing, avoid these routines, and use a Mutex. -// -// It is incorrect to make direct assignments to/from an atomic variable. -// You should use one of the Load or Store routines. The NoBarrier -// versions are provided when no barriers are needed: -// NoBarrier_Store() -// NoBarrier_Load() -// Although there are currently no compiler enforcement, you are encouraged -// to use these. -// - -#ifndef BASE_ATOMICOPS_H_ -#define BASE_ATOMICOPS_H_ - -#include <stdint.h> - -// Small C++ header which defines implementation specific macros used to -// identify the STL implementation. -// - libc++: captures __config for _LIBCPP_VERSION -// - libstdc++: captures bits/c++config.h for __GLIBCXX__ -#include <cstddef> - -#include "base/base_export.h" -#include "build_config.h" - -#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS) -// windows.h #defines this (only on x64). This causes problems because the -// public API also uses MemoryBarrier at the public name for this fence. So, on -// X64, undef it, and call its documented -// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx) -// implementation directly. -#undef MemoryBarrier -#endif - -namespace base { -namespace subtle { - -typedef int32_t Atomic32; -#ifdef ARCH_CPU_64_BITS -// We need to be able to go between Atomic64 and AtomicWord implicitly. This -// means Atomic64 and AtomicWord should be the same type on 64-bit. -#if defined(__ILP32__) || defined(OS_NACL) -// NaCl's intptr_t is not actually 64-bits on 64-bit! -// http://code.google.com/p/nativeclient/issues/detail?id=1162 -typedef int64_t Atomic64; -#else -typedef intptr_t Atomic64; -#endif -#endif - -// Use AtomicWord for a machine-sized pointer. It will use the Atomic32 or -// Atomic64 routines below, depending on your architecture. -typedef intptr_t AtomicWord; - -// Atomically execute: -// result = *ptr; -// if (*ptr == old_value) -// *ptr = new_value; -// return result; -// -// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value". -// Always return the old value of "*ptr" -// -// This routine implies no memory barriers. -Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value); - -// Atomically store new_value into *ptr, returning the previous value held in -// *ptr. This routine implies no memory barriers. -Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value); - -// Atomically increment *ptr by "increment". Returns the new value of -// *ptr with the increment applied. This routine implies no memory barriers. -Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment); - -Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, - Atomic32 increment); - -// These following lower-level operations are typically useful only to people -// implementing higher-level synchronization operations like spinlocks, -// mutexes, and condition-variables. They combine CompareAndSwap(), a load, or -// a store with appropriate memory-ordering instructions. "Acquire" operations -// ensure that no later memory access can be reordered ahead of the operation. -// "Release" operations ensure that no previous memory access can be reordered -// after the operation. "Barrier" operations have both "Acquire" and "Release" -// semantics. A MemoryBarrier() has "Barrier" semantics, but does no memory -// access. -Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value); -Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value); - -void MemoryBarrier(); -void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value); -void Acquire_Store(volatile Atomic32* ptr, Atomic32 value); -void Release_Store(volatile Atomic32* ptr, Atomic32 value); - -Atomic32 NoBarrier_Load(volatile const Atomic32* ptr); -Atomic32 Acquire_Load(volatile const Atomic32* ptr); -Atomic32 Release_Load(volatile const Atomic32* ptr); - -// 64-bit atomic operations (only available on 64-bit processors). -#ifdef ARCH_CPU_64_BITS -Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value); -Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value); -Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment); -Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment); - -Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value); -Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value); -void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value); -void Acquire_Store(volatile Atomic64* ptr, Atomic64 value); -void Release_Store(volatile Atomic64* ptr, Atomic64 value); -Atomic64 NoBarrier_Load(volatile const Atomic64* ptr); -Atomic64 Acquire_Load(volatile const Atomic64* ptr); -Atomic64 Release_Load(volatile const Atomic64* ptr); -#endif // ARCH_CPU_64_BITS - -} // namespace subtle -} // namespace base - -#if defined(OS_WIN) -// TODO(jfb): Try to use base/atomicops_internals_portable.h everywhere. -// https://crbug.com/559247. -# include "base/atomicops_internals_x86_msvc.h" -#else -# include "base/atomicops_internals_portable.h" -#endif - -// On some platforms we need additional declarations to make -// AtomicWord compatible with our other Atomic* types. -#if defined(OS_MACOSX) || defined(OS_OPENBSD) -#include "base/atomicops_internals_atomicword_compat.h" -#endif - -#endif // BASE_ATOMICOPS_H_
diff --git a/base/atomicops_internals_atomicword_compat.h b/base/atomicops_internals_atomicword_compat.h deleted file mode 100644 index d985d10..0000000 --- a/base/atomicops_internals_atomicword_compat.h +++ /dev/null
@@ -1,104 +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. - -// This file is an internal atomic implementation, use base/atomicops.h instead. - -#ifndef BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_ -#define BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_ - -#include <stdint.h> - -#include "build_config.h" - -// AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32_t, -// which in turn means int. On some LP32 platforms, intptr_t is an int, but -// on others, it's a long. When AtomicWord and Atomic32 are based on different -// fundamental types, their pointers are incompatible. -// -// This file defines function overloads to allow both AtomicWord and Atomic32 -// data to be used with this interface. -// -// On LP64 platforms, AtomicWord and Atomic64 are both always long, -// so this problem doesn't occur. - -#if !defined(ARCH_CPU_64_BITS) - -namespace base { -namespace subtle { - -inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr, - AtomicWord old_value, - AtomicWord new_value) { - return NoBarrier_CompareAndSwap( - reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); -} - -inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr, - AtomicWord new_value) { - return NoBarrier_AtomicExchange( - reinterpret_cast<volatile Atomic32*>(ptr), new_value); -} - -inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr, - AtomicWord increment) { - return NoBarrier_AtomicIncrement( - reinterpret_cast<volatile Atomic32*>(ptr), increment); -} - -inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr, - AtomicWord increment) { - return Barrier_AtomicIncrement( - reinterpret_cast<volatile Atomic32*>(ptr), increment); -} - -inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr, - AtomicWord old_value, - AtomicWord new_value) { - return base::subtle::Acquire_CompareAndSwap( - reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); -} - -inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr, - AtomicWord old_value, - AtomicWord new_value) { - return base::subtle::Release_CompareAndSwap( - reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); -} - -inline void NoBarrier_Store(volatile AtomicWord *ptr, AtomicWord value) { - NoBarrier_Store( - reinterpret_cast<volatile Atomic32*>(ptr), value); -} - -inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) { - return base::subtle::Acquire_Store( - reinterpret_cast<volatile Atomic32*>(ptr), value); -} - -inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) { - return base::subtle::Release_Store( - reinterpret_cast<volatile Atomic32*>(ptr), value); -} - -inline AtomicWord NoBarrier_Load(volatile const AtomicWord *ptr) { - return NoBarrier_Load( - reinterpret_cast<volatile const Atomic32*>(ptr)); -} - -inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) { - return base::subtle::Acquire_Load( - reinterpret_cast<volatile const Atomic32*>(ptr)); -} - -inline AtomicWord Release_Load(volatile const AtomicWord* ptr) { - return base::subtle::Release_Load( - reinterpret_cast<volatile const Atomic32*>(ptr)); -} - -} // namespace subtle -} // namespace base - -#endif // !defined(ARCH_CPU_64_BITS) - -#endif // BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
diff --git a/base/atomicops_internals_portable.h b/base/atomicops_internals_portable.h deleted file mode 100644 index b75d080..0000000 --- a/base/atomicops_internals_portable.h +++ /dev/null
@@ -1,229 +0,0 @@ -// Copyright (c) 2014 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. - -// This file is an internal atomic implementation, use atomicops.h instead. -// -// This implementation uses C++11 atomics' member functions. The code base is -// currently written assuming atomicity revolves around accesses instead of -// C++11's memory locations. The burden is on the programmer to ensure that all -// memory locations accessed atomically are never accessed non-atomically (tsan -// should help with this). -// -// TODO(jfb) Modify the atomicops.h API and user code to declare atomic -// locations as truly atomic. See the static_assert below. -// -// Of note in this implementation: -// * All NoBarrier variants are implemented as relaxed. -// * All Barrier variants are implemented as sequentially-consistent. -// * Compare exchange's failure ordering is always the same as the success one -// (except for release, which fails as relaxed): using a weaker ordering is -// only valid under certain uses of compare exchange. -// * Acquire store doesn't exist in the C11 memory model, it is instead -// implemented as a relaxed store followed by a sequentially consistent -// fence. -// * Release load doesn't exist in the C11 memory model, it is instead -// implemented as sequentially consistent fence followed by a relaxed load. -// * Atomic increment is expected to return the post-incremented value, whereas -// C11 fetch add returns the previous value. The implementation therefore -// needs to increment twice (which the compiler should be able to detect and -// optimize). - -#ifndef BASE_ATOMICOPS_INTERNALS_PORTABLE_H_ -#define BASE_ATOMICOPS_INTERNALS_PORTABLE_H_ - -#include <atomic> - -#include "build_config.h" - -namespace base { -namespace subtle { - -// This implementation is transitional and maintains the original API for -// atomicops.h. This requires casting memory locations to the atomic types, and -// assumes that the API and the C++11 implementation are layout-compatible, -// which isn't true for all implementations or hardware platforms. The static -// assertion should detect this issue, were it to fire then this header -// shouldn't be used. -// -// TODO(jfb) If this header manages to stay committed then the API should be -// modified, and all call sites updated. -typedef volatile std::atomic<Atomic32>* AtomicLocation32; -static_assert(sizeof(*(AtomicLocation32) nullptr) == sizeof(Atomic32), - "incompatible 32-bit atomic layout"); - -inline void MemoryBarrier() { -#if defined(__GLIBCXX__) - // Work around libstdc++ bug 51038 where atomic_thread_fence was declared but - // not defined, leading to the linker complaining about undefined references. - __atomic_thread_fence(std::memory_order_seq_cst); -#else - std::atomic_thread_fence(std::memory_order_seq_cst); -#endif -} - -inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value) { - ((AtomicLocation32)ptr) - ->compare_exchange_strong(old_value, - new_value, - std::memory_order_relaxed, - std::memory_order_relaxed); - return old_value; -} - -inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, - Atomic32 new_value) { - return ((AtomicLocation32)ptr) - ->exchange(new_value, std::memory_order_relaxed); -} - -inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, - Atomic32 increment) { - return increment + - ((AtomicLocation32)ptr) - ->fetch_add(increment, std::memory_order_relaxed); -} - -inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, - Atomic32 increment) { - return increment + ((AtomicLocation32)ptr)->fetch_add(increment); -} - -inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value) { - ((AtomicLocation32)ptr) - ->compare_exchange_strong(old_value, - new_value, - std::memory_order_acquire, - std::memory_order_acquire); - return old_value; -} - -inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value) { - ((AtomicLocation32)ptr) - ->compare_exchange_strong(old_value, - new_value, - std::memory_order_release, - std::memory_order_relaxed); - return old_value; -} - -inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { - ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed); -} - -inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { - ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed); - MemoryBarrier(); -} - -inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { - ((AtomicLocation32)ptr)->store(value, std::memory_order_release); -} - -inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { - return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed); -} - -inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { - return ((AtomicLocation32)ptr)->load(std::memory_order_acquire); -} - -inline Atomic32 Release_Load(volatile const Atomic32* ptr) { - MemoryBarrier(); - return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed); -} - -#if defined(ARCH_CPU_64_BITS) - -typedef volatile std::atomic<Atomic64>* AtomicLocation64; -static_assert(sizeof(*(AtomicLocation64) nullptr) == sizeof(Atomic64), - "incompatible 64-bit atomic layout"); - -inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value) { - ((AtomicLocation64)ptr) - ->compare_exchange_strong(old_value, - new_value, - std::memory_order_relaxed, - std::memory_order_relaxed); - return old_value; -} - -inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, - Atomic64 new_value) { - return ((AtomicLocation64)ptr) - ->exchange(new_value, std::memory_order_relaxed); -} - -inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, - Atomic64 increment) { - return increment + - ((AtomicLocation64)ptr) - ->fetch_add(increment, std::memory_order_relaxed); -} - -inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, - Atomic64 increment) { - return increment + ((AtomicLocation64)ptr)->fetch_add(increment); -} - -inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value) { - ((AtomicLocation64)ptr) - ->compare_exchange_strong(old_value, - new_value, - std::memory_order_acquire, - std::memory_order_acquire); - return old_value; -} - -inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value) { - ((AtomicLocation64)ptr) - ->compare_exchange_strong(old_value, - new_value, - std::memory_order_release, - std::memory_order_relaxed); - return old_value; -} - -inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { - ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed); -} - -inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { - ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed); - MemoryBarrier(); -} - -inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { - ((AtomicLocation64)ptr)->store(value, std::memory_order_release); -} - -inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { - return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed); -} - -inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { - return ((AtomicLocation64)ptr)->load(std::memory_order_acquire); -} - -inline Atomic64 Release_Load(volatile const Atomic64* ptr) { - MemoryBarrier(); - return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed); -} - -#endif // defined(ARCH_CPU_64_BITS) -} // namespace subtle -} // namespace base - -#endif // BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
diff --git a/base/atomicops_internals_x86_msvc.h b/base/atomicops_internals_x86_msvc.h deleted file mode 100644 index 38001a8..0000000 --- a/base/atomicops_internals_x86_msvc.h +++ /dev/null
@@ -1,198 +0,0 @@ -// Copyright (c) 2006-2008 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. - -// This file is an internal atomic implementation, use base/atomicops.h instead. - -#ifndef BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_ -#define BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_ - -#include "base/win/windows_types.h" - -#include <intrin.h> - -#include "base/macros.h" -#include "build_config.h" - -#if defined(ARCH_CPU_64_BITS) -// windows.h #defines this (only on x64). This causes problems because the -// public API also uses MemoryBarrier at the public name for this fence. So, on -// X64, undef it, and call its documented -// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx) -// implementation directly. -#undef MemoryBarrier -#endif - -namespace base { -namespace subtle { - -inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value) { - LONG result = _InterlockedCompareExchange( - reinterpret_cast<volatile LONG*>(ptr), - static_cast<LONG>(new_value), - static_cast<LONG>(old_value)); - return static_cast<Atomic32>(result); -} - -inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, - Atomic32 new_value) { - LONG result = _InterlockedExchange( - reinterpret_cast<volatile LONG*>(ptr), - static_cast<LONG>(new_value)); - return static_cast<Atomic32>(result); -} - -inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, - Atomic32 increment) { - return _InterlockedExchangeAdd( - reinterpret_cast<volatile LONG*>(ptr), - static_cast<LONG>(increment)) + increment; -} - -inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, - Atomic32 increment) { - return Barrier_AtomicIncrement(ptr, increment); -} - -inline void MemoryBarrier() { -#if defined(ARCH_CPU_64_BITS) - // See #undef and note at the top of this file. - __faststorefence(); -#else - // We use the implementation of MemoryBarrier from WinNT.h - LONG barrier; - - _InterlockedOr(&barrier, 0); -#endif -} - -inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value) { - return NoBarrier_CompareAndSwap(ptr, old_value, new_value); -} - -inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, - Atomic32 old_value, - Atomic32 new_value) { - return NoBarrier_CompareAndSwap(ptr, old_value, new_value); -} - -inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { - *ptr = value; -} - -inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { - NoBarrier_AtomicExchange(ptr, value); - // acts as a barrier in this implementation -} - -inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { - *ptr = value; // works w/o barrier for current Intel chips as of June 2005 - // See comments in Atomic64 version of Release_Store() below. -} - -inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { - return *ptr; -} - -inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { - Atomic32 value = *ptr; - return value; -} - -inline Atomic32 Release_Load(volatile const Atomic32* ptr) { - MemoryBarrier(); - return *ptr; -} - -#if defined(_WIN64) - -// 64-bit low-level operations on 64-bit platform. - -static_assert(sizeof(Atomic64) == sizeof(PVOID), "atomic word is atomic"); - -inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value) { - PVOID result = _InterlockedCompareExchangePointer( - reinterpret_cast<volatile PVOID*>(ptr), - reinterpret_cast<PVOID>(new_value), reinterpret_cast<PVOID>(old_value)); - return reinterpret_cast<Atomic64>(result); -} - -inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, - Atomic64 new_value) { - PVOID result = - _InterlockedExchangePointer(reinterpret_cast<volatile PVOID*>(ptr), - reinterpret_cast<PVOID>(new_value)); - return reinterpret_cast<Atomic64>(result); -} - -inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, - Atomic64 increment) { - return _InterlockedExchangeAdd64(reinterpret_cast<volatile LONGLONG*>(ptr), - static_cast<LONGLONG>(increment)) + - increment; -} - -inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, - Atomic64 increment) { - return Barrier_AtomicIncrement(ptr, increment); -} - -inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { - *ptr = value; -} - -inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { - NoBarrier_AtomicExchange(ptr, value); - // acts as a barrier in this implementation -} - -inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { - *ptr = value; // works w/o barrier for current Intel chips as of June 2005 - - // When new chips come out, check: - // IA-32 Intel Architecture Software Developer's Manual, Volume 3: - // System Programming Guide, Chatper 7: Multiple-processor management, - // Section 7.2, Memory Ordering. - // Last seen at: - // http://developer.intel.com/design/pentium4/manuals/index_new.htm -} - -inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { - return *ptr; -} - -inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { - Atomic64 value = *ptr; - return value; -} - -inline Atomic64 Release_Load(volatile const Atomic64* ptr) { - MemoryBarrier(); - return *ptr; -} - -inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value) { - return NoBarrier_CompareAndSwap(ptr, old_value, new_value); -} - -inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, - Atomic64 old_value, - Atomic64 new_value) { - return NoBarrier_CompareAndSwap(ptr, old_value, new_value); -} - - -#endif // defined(_WIN64) - -} // namespace subtle -} // namespace base - -#endif // BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_
diff --git a/base/bind_helpers.h b/base/bind_helpers.h deleted file mode 100644 index f4bbd80..0000000 --- a/base/bind_helpers.h +++ /dev/null
@@ -1,69 +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. - -#ifndef BASE_BIND_HELPERS_H_ -#define BASE_BIND_HELPERS_H_ - -#include <stddef.h> - -#include <type_traits> -#include <utility> - -#include "base/bind.h" -#include "base/callback.h" -#include "base/memory/weak_ptr.h" -#include "build_config.h" - -// This defines a set of simple functions and utilities that people want when -// using Callback<> and Bind(). - -namespace base { - -// Creates a null callback. -class BASE_EXPORT NullCallback { - public: - template <typename R, typename... Args> - operator RepeatingCallback<R(Args...)>() const { - return RepeatingCallback<R(Args...)>(); - } - template <typename R, typename... Args> - operator OnceCallback<R(Args...)>() const { - return OnceCallback<R(Args...)>(); - } -}; - -// Creates a callback that does nothing when called. -class BASE_EXPORT DoNothing { - public: - template <typename... Args> - operator RepeatingCallback<void(Args...)>() const { - return Repeatedly<Args...>(); - } - template <typename... Args> - operator OnceCallback<void(Args...)>() const { - return Once<Args...>(); - } - // Explicit way of specifying a specific callback type when the compiler can't - // deduce it. - template <typename... Args> - static RepeatingCallback<void(Args...)> Repeatedly() { - return BindRepeating([](Args... args) {}); - } - template <typename... Args> - static OnceCallback<void(Args...)> Once() { - return BindOnce([](Args... args) {}); - } -}; - -// Useful for creating a Closure that will delete a pointer when invoked. Only -// use this when necessary. In most cases MessageLoop::DeleteSoon() is a better -// fit. -template <typename T> -void DeletePointer(T* obj) { - delete obj; -} - -} // namespace base - -#endif // BASE_BIND_HELPERS_H_
diff --git a/base/bits.h b/base/bits.h deleted file mode 100644 index b02f303..0000000 --- a/base/bits.h +++ /dev/null
@@ -1,184 +0,0 @@ -// 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. - -// This file defines some bit utilities. - -#ifndef BASE_BITS_H_ -#define BASE_BITS_H_ - -#include <stddef.h> -#include <stdint.h> - -#include "base/compiler_specific.h" -#include "base/logging.h" -#include "build_config.h" - -#if defined(COMPILER_MSVC) -#include <intrin.h> -#endif - -namespace base { -namespace bits { - -// Returns true iff |value| is a power of 2. -template <typename T, - typename = typename std::enable_if<std::is_integral<T>::value>> -constexpr inline bool IsPowerOfTwo(T value) { - // From "Hacker's Delight": Section 2.1 Manipulating Rightmost Bits. - // - // Only positive integers with a single bit set are powers of two. If only one - // bit is set in x (e.g. 0b00000100000000) then |x-1| will have that bit set - // to zero and all bits to its right set to 1 (e.g. 0b00000011111111). Hence - // |x & (x-1)| is 0 iff x is a power of two. - return value > 0 && (value & (value - 1)) == 0; -} - -// Round up |size| to a multiple of alignment, which must be a power of two. -inline size_t Align(size_t size, size_t alignment) { - DCHECK(IsPowerOfTwo(alignment)); - return (size + alignment - 1) & ~(alignment - 1); -} - -// CountLeadingZeroBits(value) returns the number of zero bits following the -// most significant 1 bit in |value| if |value| is non-zero, otherwise it -// returns {sizeof(T) * 8}. -// Example: 00100010 -> 2 -// -// CountTrailingZeroBits(value) returns the number of zero bits preceding the -// least significant 1 bit in |value| if |value| is non-zero, otherwise it -// returns {sizeof(T) * 8}. -// Example: 00100010 -> 1 -// -// C does not have an operator to do this, but fortunately the various -// compilers have built-ins that map to fast underlying processor instructions. -#if defined(COMPILER_MSVC) - -template <typename T, unsigned bits = sizeof(T) * 8> -ALWAYS_INLINE - typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 4, - unsigned>::type - CountLeadingZeroBits(T x) { - static_assert(bits > 0, "invalid instantiation"); - unsigned long index; - return LIKELY(_BitScanReverse(&index, static_cast<uint32_t>(x))) - ? (31 - index - (32 - bits)) - : bits; -} - -template <typename T, unsigned bits = sizeof(T) * 8> -ALWAYS_INLINE - typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) == 8, - unsigned>::type - CountLeadingZeroBits(T x) { - static_assert(bits > 0, "invalid instantiation"); - unsigned long index; - return LIKELY(_BitScanReverse64(&index, static_cast<uint64_t>(x))) - ? (63 - index) - : 64; -} - -template <typename T, unsigned bits = sizeof(T) * 8> -ALWAYS_INLINE - typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 4, - unsigned>::type - CountTrailingZeroBits(T x) { - static_assert(bits > 0, "invalid instantiation"); - unsigned long index; - return LIKELY(_BitScanForward(&index, static_cast<uint32_t>(x))) ? index - : bits; -} - -template <typename T, unsigned bits = sizeof(T) * 8> -ALWAYS_INLINE - typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) == 8, - unsigned>::type - CountTrailingZeroBits(T x) { - static_assert(bits > 0, "invalid instantiation"); - unsigned long index; - return LIKELY(_BitScanForward64(&index, static_cast<uint64_t>(x))) ? index - : 64; -} - -ALWAYS_INLINE uint32_t CountLeadingZeroBits32(uint32_t x) { - return CountLeadingZeroBits(x); -} - -#if defined(ARCH_CPU_64_BITS) - -// MSVC only supplies _BitScanForward64 when building for a 64-bit target. -ALWAYS_INLINE uint64_t CountLeadingZeroBits64(uint64_t x) { - return CountLeadingZeroBits(x); -} - -#endif - -#elif defined(COMPILER_GCC) - -// __builtin_clz has undefined behaviour for an input of 0, even though there's -// clearly a return value that makes sense, and even though some processor clz -// instructions have defined behaviour for 0. We could drop to raw __asm__ to -// do better, but we'll avoid doing that unless we see proof that we need to. -template <typename T, unsigned bits = sizeof(T) * 8> -ALWAYS_INLINE - typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8, - unsigned>::type - CountLeadingZeroBits(T value) { - static_assert(bits > 0, "invalid instantiation"); - return LIKELY(value) - ? bits == 64 - ? __builtin_clzll(static_cast<uint64_t>(value)) - : __builtin_clz(static_cast<uint32_t>(value)) - (32 - bits) - : bits; -} - -template <typename T, unsigned bits = sizeof(T) * 8> -ALWAYS_INLINE - typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8, - unsigned>::type - CountTrailingZeroBits(T value) { - return LIKELY(value) ? bits == 64 - ? __builtin_ctzll(static_cast<uint64_t>(value)) - : __builtin_ctz(static_cast<uint32_t>(value)) - : bits; -} - -ALWAYS_INLINE uint32_t CountLeadingZeroBits32(uint32_t x) { - return CountLeadingZeroBits(x); -} - -#if defined(ARCH_CPU_64_BITS) - -ALWAYS_INLINE uint64_t CountLeadingZeroBits64(uint64_t x) { - return CountLeadingZeroBits(x); -} - -#endif - -#endif - -ALWAYS_INLINE size_t CountLeadingZeroBitsSizeT(size_t x) { - return CountLeadingZeroBits(x); -} - -ALWAYS_INLINE size_t CountTrailingZeroBitsSizeT(size_t x) { - return CountTrailingZeroBits(x); -} - -// Returns the integer i such as 2^i <= n < 2^(i+1) -inline int Log2Floor(uint32_t n) { - return 31 - CountLeadingZeroBits(n); -} - -// Returns the integer i such as 2^(i-1) < n <= 2^i -inline int Log2Ceiling(uint32_t n) { - // When n == 0, we want the function to return -1. - // When n == 0, (n - 1) will underflow to 0xFFFFFFFF, which is - // why the statement below starts with (n ? 32 : -1). - return (n ? 32 : -1) - CountLeadingZeroBits(n - 1); -} - -} // namespace bits -} // namespace base - -#endif // BASE_BITS_H_
diff --git a/base/callback_helpers.cc b/base/callback_helpers.cc deleted file mode 100644 index 9086731..0000000 --- a/base/callback_helpers.cc +++ /dev/null
@@ -1,40 +0,0 @@ -// Copyright 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/callback_helpers.h" - -namespace base { - -ScopedClosureRunner::ScopedClosureRunner() = default; - -ScopedClosureRunner::ScopedClosureRunner(OnceClosure closure) - : closure_(std::move(closure)) {} - -ScopedClosureRunner::~ScopedClosureRunner() { - if (!closure_.is_null()) - std::move(closure_).Run(); -} - -ScopedClosureRunner::ScopedClosureRunner(ScopedClosureRunner&& other) - : closure_(other.Release()) {} - -ScopedClosureRunner& ScopedClosureRunner::operator=( - ScopedClosureRunner&& other) { - ReplaceClosure(other.Release()); - return *this; -} - -void ScopedClosureRunner::RunAndReset() { - std::move(closure_).Run(); -} - -void ScopedClosureRunner::ReplaceClosure(OnceClosure closure) { - closure_ = std::move(closure); -} - -OnceClosure ScopedClosureRunner::Release() { - return std::move(closure_); -} - -} // namespace base
diff --git a/base/callback_helpers.h b/base/callback_helpers.h deleted file mode 100644 index 0cdda6d..0000000 --- a/base/callback_helpers.h +++ /dev/null
@@ -1,104 +0,0 @@ -// Copyright (c) 2012 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. - -// This defines helpful methods for dealing with Callbacks. Because Callbacks -// are implemented using templates, with a class per callback signature, adding -// methods to Callback<> itself is unattractive (lots of extra code gets -// generated). Instead, consider adding methods here. - -#ifndef BASE_CALLBACK_HELPERS_H_ -#define BASE_CALLBACK_HELPERS_H_ - -#include <utility> - -#include "base/atomicops.h" -#include "base/bind.h" -#include "base/callback.h" -#include "base/compiler_specific.h" -#include "base/macros.h" -#include "base/memory/ptr_util.h" - -namespace base { - -// Prefer std::move() over ResetAndReturn(). -template <typename CallbackType> -CallbackType ResetAndReturn(CallbackType* cb) { - CallbackType ret(std::move(*cb)); - DCHECK(!*cb); - return ret; -} - -namespace internal { - -template <typename... Args> -class AdaptCallbackForRepeatingHelper final { - public: - explicit AdaptCallbackForRepeatingHelper(OnceCallback<void(Args...)> callback) - : callback_(std::move(callback)) { - DCHECK(callback_); - } - - void Run(Args... args) { - if (subtle::NoBarrier_AtomicExchange(&has_run_, 1)) - return; - DCHECK(callback_); - std::move(callback_).Run(std::forward<Args>(args)...); - } - - private: - volatile subtle::Atomic32 has_run_ = 0; - base::OnceCallback<void(Args...)> callback_; - - DISALLOW_COPY_AND_ASSIGN(AdaptCallbackForRepeatingHelper); -}; - -} // namespace internal - -// Wraps the given OnceCallback into a RepeatingCallback that relays its -// invocation to the original OnceCallback on the first invocation. The -// following invocations are just ignored. -// -// Note that this deliberately subverts the Once/Repeating paradigm of Callbacks -// but helps ease the migration from old-style Callbacks. Avoid if possible; use -// if necessary for migration. TODO(tzik): Remove it. https://crbug.com/730593 -template <typename... Args> -RepeatingCallback<void(Args...)> AdaptCallbackForRepeating( - OnceCallback<void(Args...)> callback) { - using Helper = internal::AdaptCallbackForRepeatingHelper<Args...>; - return base::BindRepeating(&Helper::Run, - std::make_unique<Helper>(std::move(callback))); -} - -// ScopedClosureRunner is akin to std::unique_ptr<> for Closures. It ensures -// that the Closure is executed no matter how the current scope exits. -class BASE_EXPORT ScopedClosureRunner { - public: - ScopedClosureRunner(); - explicit ScopedClosureRunner(OnceClosure closure); - ~ScopedClosureRunner(); - - ScopedClosureRunner(ScopedClosureRunner&& other); - - // Releases the current closure if it's set and replaces it with the closure - // from |other|. - ScopedClosureRunner& operator=(ScopedClosureRunner&& other); - - // Calls the current closure and resets it, so it wont be called again. - void RunAndReset(); - - // Replaces closure with the new one releasing the old one without calling it. - void ReplaceClosure(OnceClosure closure); - - // Releases the Closure without calling. - OnceClosure Release() WARN_UNUSED_RESULT; - - private: - OnceClosure closure_; - - DISALLOW_COPY_AND_ASSIGN(ScopedClosureRunner); -}; - -} // namespace base - -#endif // BASE_CALLBACK_HELPERS_H_
diff --git a/base/time/time_win.cc b/base/time/time_win.cc index 6767fd6..ba220d6 100644 --- a/base/time/time_win.cc +++ b/base/time/time_win.cc
@@ -37,7 +37,6 @@ #include <mmsystem.h> #include <stdint.h> -#include "base/atomicops.h" #include "base/bit_cast.h" #include "base/logging.h" #include "base/synchronization/lock.h"
diff --git a/base/win/wrapped_window_proc.cc b/base/win/wrapped_window_proc.cc deleted file mode 100644 index 0a00996..0000000 --- a/base/win/wrapped_window_proc.cc +++ /dev/null
@@ -1,78 +0,0 @@ -// Copyright (c) 2012 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/win/wrapped_window_proc.h" - -#include "base/atomicops.h" -#include "base/logging.h" - -namespace { - -base::win::WinProcExceptionFilter s_exception_filter = NULL; - -HMODULE GetModuleFromWndProc(WNDPROC window_proc) { - HMODULE instance = NULL; - // Converting a pointer-to-function to a void* is undefined behavior, but - // Windows (and POSIX) APIs require it to work. - void* address = reinterpret_cast<void*>(window_proc); - if (!::GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | - GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, - static_cast<char*>(address), - &instance)) { - NOTREACHED(); - } - return instance; -} - -} // namespace. - -namespace base { -namespace win { - -WinProcExceptionFilter SetWinProcExceptionFilter( - WinProcExceptionFilter filter) { - subtle::AtomicWord rv = subtle::NoBarrier_AtomicExchange( - reinterpret_cast<subtle::AtomicWord*>(&s_exception_filter), - reinterpret_cast<subtle::AtomicWord>(filter)); - return reinterpret_cast<WinProcExceptionFilter>(rv); -} - -int CallExceptionFilter(EXCEPTION_POINTERS* info) { - return s_exception_filter ? s_exception_filter(info) : - EXCEPTION_CONTINUE_SEARCH; -} - -BASE_EXPORT void InitializeWindowClass( - const char16* class_name, - WNDPROC window_proc, - UINT style, - int class_extra, - int window_extra, - HCURSOR cursor, - HBRUSH background, - const char16* menu_name, - HICON large_icon, - HICON small_icon, - WNDCLASSEX* class_out) { - class_out->cbSize = sizeof(WNDCLASSEX); - class_out->style = style; - class_out->lpfnWndProc = window_proc; - class_out->cbClsExtra = class_extra; - class_out->cbWndExtra = window_extra; - // RegisterClassEx uses a handle of the module containing the window procedure - // to distinguish identically named classes registered in different modules. - class_out->hInstance = GetModuleFromWndProc(window_proc); - class_out->hIcon = large_icon; - class_out->hCursor = cursor; - class_out->hbrBackground = background; - class_out->lpszMenuName = menu_name; - class_out->lpszClassName = class_name; - class_out->hIconSm = small_icon; - - // Check if |window_proc| is valid. - DCHECK(class_out->hInstance != NULL); -} - -} // namespace win -} // namespace base
diff --git a/base/win/wrapped_window_proc.h b/base/win/wrapped_window_proc.h deleted file mode 100644 index c586be0..0000000 --- a/base/win/wrapped_window_proc.h +++ /dev/null
@@ -1,85 +0,0 @@ -// Copyright (c) 2012 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. - -// Provides a way to handle exceptions that happen while a WindowProc is -// running. The behavior of exceptions generated inside a WindowProc is OS -// dependent, but it is possible that the OS just ignores the exception and -// continues execution, which leads to unpredictable behavior for Chrome. - -#ifndef BASE_WIN_WRAPPED_WINDOW_PROC_H_ -#define BASE_WIN_WRAPPED_WINDOW_PROC_H_ - -#include <windows.h> - -#include "base/base_export.h" -#include "base/strings/string16.h" - -namespace base { -namespace win { - -// An exception filter for a WindowProc. The return value determines how the -// exception should be handled, following standard SEH rules. However, the -// expected behavior for this function is to not return, instead of returning -// EXCEPTION_EXECUTE_HANDLER or similar, given that in general we are not -// prepared to handle exceptions. -typedef int (__cdecl *WinProcExceptionFilter)(EXCEPTION_POINTERS* info); - -// Sets the filter to deal with exceptions inside a WindowProc. Returns the old -// exception filter, if any. -// This function should be called before any window is created. -BASE_EXPORT WinProcExceptionFilter SetWinProcExceptionFilter( - WinProcExceptionFilter filter); - -// Calls the registered exception filter. -BASE_EXPORT int CallExceptionFilter(EXCEPTION_POINTERS* info); - -// Initializes the WNDCLASSEX structure |*class_out| to be passed to -// RegisterClassEx() making sure that it is associated with the module -// containing the window procedure. -BASE_EXPORT void InitializeWindowClass( - const char16* class_name, - WNDPROC window_proc, - UINT style, - int class_extra, - int window_extra, - HCURSOR cursor, - HBRUSH background, - const char16* menu_name, - HICON large_icon, - HICON small_icon, - WNDCLASSEX* class_out); - -// Wrapper that supplies a standard exception frame for the provided WindowProc. -// The normal usage is something like this: -// -// LRESULT CALLBACK MyWinProc(HWND hwnd, UINT message, -// WPARAM wparam, LPARAM lparam) { -// // Do Something. -// } -// -// ... -// -// WNDCLASSEX wc = {0}; -// wc.lpfnWndProc = WrappedWindowProc<MyWinProc>; -// wc.lpszClassName = class_name; -// ... -// RegisterClassEx(&wc); -// -// CreateWindowW(class_name, window_name, ... -// -template <WNDPROC proc> -LRESULT CALLBACK -WrappedWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) { - LRESULT rv = 0; - __try { - rv = proc(hwnd, message, wparam, lparam); - } __except(CallExceptionFilter(GetExceptionInformation())) { - } - return rv; -} - -} // namespace win -} // namespace base - -#endif // BASE_WIN_WRAPPED_WINDOW_PROC_H_
diff --git a/build/gen.py b/build/gen.py index ed92d2f..318e728 100755 --- a/build/gen.py +++ b/build/gen.py
@@ -225,7 +225,6 @@ static_libraries = { 'base': {'sources': [ - 'base/callback_helpers.cc', 'base/callback_internal.cc', 'base/command_line.cc', 'base/environment.cc', @@ -566,7 +565,6 @@ 'base/win/wait_chain.cc', 'base/win/win_util.cc', 'base/win/windows_version.cc', - 'base/win/wrapped_window_proc.cc', ]) libs.extend([