| /external/chromium_org/ppapi/utility/threading/ |
| lock.cc | 5 #include "ppapi/utility/threading/lock.h"
11 Lock::Lock() {
17 Lock::~Lock() {
21 void Lock::Acquire() {
25 void Lock::Release() {
31 Lock::Lock() {
35 Lock::~Lock()
[all...] |
| lock.h | 16 /// A simple wrapper around a platform-specific lock. See also AutoLock.
17 class Lock {
19 /// Creates a lock in the "not held" state.
20 Lock();
22 /// Destroys the lock.
23 ~Lock();
25 /// Acquires the lock, blocking if it's already held by a different thread.
26 /// The lock must not already be held on the current thread (i.e. recursive
30 /// acquire and release the lock.
33 /// Releases the lock. This must be paired with a call to Acquire()
[all...] |
| /external/chromium_org/third_party/sfntly/cpp/src/sfntly/port/ |
| lock.cc | 17 #include "sfntly/port/lock.h"
23 Lock::Lock() {
29 Lock::~Lock() {
33 bool Lock::Try() {
40 void Lock::Acquire() {
44 void Lock::Unlock() {
50 Lock::Lock() {
[all...] |
| lock.h | 37 class Lock {
39 Lock();
40 ~Lock();
42 // If the lock is not held, take it and return true. If the lock is already
46 // Take the lock, blocking until it is available if necessary.
49 // Release the lock. This must only be called by the lock's holder: after
50 // a successful call to Try, or a call to Lock.
55 NO_COPY_AND_ASSIGN(Lock);
[all...] |
| /external/sfntly/cpp/src/sfntly/port/ |
| lock.cc | 17 #include "sfntly/port/lock.h"
23 Lock::Lock() {
29 Lock::~Lock() {
33 bool Lock::Try() {
40 void Lock::Acquire() {
44 void Lock::Unlock() {
50 Lock::Lock() {
[all...] |
| lock.h | 37 class Lock {
39 Lock();
40 ~Lock();
42 // If the lock is not held, take it and return true. If the lock is already
46 // Take the lock, blocking until it is available if necessary.
49 // Release the lock. This must only be called by the lock's holder: after
50 // a successful call to Try, or a call to Lock.
55 NO_COPY_AND_ASSIGN(Lock);
[all...] |
| /external/chromium_org/base/synchronization/ |
| lock.cc | 5 // This file is used for debugging assertion support. The Lock class
11 #include "base/synchronization/lock.h"
16 Lock::Lock() : lock_() {
19 Lock::~Lock() {
23 void Lock::AssertAcquired() const {
27 void Lock::CheckHeldAndUnmark() {
32 void Lock::CheckUnheldAndMark() {
|
| lock.h | 17 class BASE_EXPORT Lock {
20 Lock() : lock_() {}
21 ~Lock() {}
22 void Acquire() { lock_.Lock(); }
25 // If the lock is not held, take it and return true. If the lock is already
27 // by a thread already holding the lock (what happens is undefined and an
34 Lock();
35 ~Lock();
39 // acquire the lock a second time (while already holding it)
[all...] |
| /external/chromium_org/crypto/ |
| mac_security_services_lock.h | 11 class Lock;
21 CRYPTO_EXPORT base::Lock& GetMacSecurityServicesLock();
|
| mac_security_services_lock.cc | 8 #include "base/synchronization/lock.h"
21 base::Lock& lock() { return lock_; } function in class:__anon12200::SecurityServicesSingleton
29 base::Lock lock_;
38 base::Lock& GetMacSecurityServicesLock() {
39 return SecurityServicesSingleton::GetInstance()->lock();
|
| /libcore/luni/src/main/java/java/util/concurrent/locks/ |
| ReadWriteLock.java | 11 * Lock locks}, one for read-only operations and one for writing.
12 * The {@link #readLock read lock} may be held simultaneously by
14 * {@link #writeLock write lock} is exclusive.
18 * (as specified in the {@link Lock} interface) also hold with respect
20 * acquiring the read lock will see all updates made upon previous
21 * release of the write lock.
23 * <p>A read-write lock allows for a greater level of concurrency in
24 * accessing shared data than that permitted by a mutual exclusion lock.
30 * lock will lead to performance improvements over the use of a mutual
31 * exclusion lock. In practice this increase in concurrency will only be full
[all...] |
| /external/clang/test/SemaCXX/ |
| operator-arrow-temporary.cpp | 8 template<int x> struct Lock {
9 ~Lock() { int a[x]; } // expected-error {{declared as an array with a negative size}}
14 Lock<-1> operator->();
17 // Make sure we try to instantiate the destructor for Lock here
|
| /prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8/x86_64-w64-mingw32/include/ |
| dmo.h | 25 #define Lock DMOLock
29 #undef Lock
|
| /external/chromium_org/third_party/libphonenumber/src/phonenumbers/base/synchronization/ |
| lock_posix.h | 28 class Lock {
30 Lock() {
36 ~Lock() {
55 DISALLOW_COPY_AND_ASSIGN(Lock);
|
| lock.h | 26 typedef boost::mutex Lock;
37 // Dummy lock implementation on non-POSIX platforms. If you are running on a
45 class Lock {
47 Lock() : thread_checker_() {}
73 AutoLock(Lock& lock) : lock_(lock) {
82 Lock& lock_;
|
| /external/chromium_org/base/third_party/dmg_fp/ |
| dtoa_wrapper.cc | 9 #include "base/synchronization/lock.h"
12 // A single lock would lead to an attempted recursive grab.
13 static base::LazyInstance<base::Lock>::Leaky
15 static base::LazyInstance<base::Lock>::Leaky
25 * by FREE_DTOA_LOCK(n) for n = 0 or 1. (The second lock, accessed
27 * powers of 5; omitting this lock would introduce a small
36 base::Lock* lock = n == 0 ? dtoa_lock_0.Pointer() : dtoa_lock_1.Pointer();
37 lock->Acquire();
42 base::Lock* lock = n == 0 ? dtoa_lock_0.Pointer() : dtoa_lock_1.Pointer()
[all...] |
| /external/chromium_org/ppapi/utility/ |
| completion_callback_factory_thread_traits.h | 10 #include "ppapi/utility/threading/lock.h"
33 /// Implementation note: this uses a lock instead of atomic add instructions.
50 AutoLock lock(lock_);
58 AutoLock lock(lock_);
64 Lock lock_;
68 typedef pp::Lock Lock;
119 /// A simple object that acts like a lock but does nothing.
123 /// asserts that the caller does not recursively lock.
124 class Lock {
[all...] |
| /external/clang/test/PCH/ |
| thread-safety-attrs.cpp | 35 void Lock() __attribute__((exclusive_lock_function));
64 // The universal lock, written "*", allows checking to be selectively turned
118 sls_mw.mu.Lock();
124 sls_mu.Lock();
130 sls_mu.Lock();
136 sls_mu2.Lock();
142 sls_mu.Lock();
148 sls_mu.Lock();
154 sls_mu.Lock();
155 sls_mu2.Lock();
[all...] |
| /external/chromium_org/third_party/skia/include/core/ |
| SkOnce.h | 44 // If you've already got a lock and a flag to use, this variant lets you avoid an extra SkOnceFlag.
45 template <typename Lock>
46 inline void SkOnce(bool* done, Lock* lock, void (*f)());
48 template <typename Lock, typename Arg>
49 inline void SkOnce(bool* done, Lock* lock, void (*f)(Arg), Arg arg);
85 template <typename Lock, typename Arg>
86 static void sk_once_slow(bool* done, Lock* lock, void (*f)(Arg), Arg arg)
[all...] |
| /external/chromium_org/v8/test/cctest/ |
| test-mutex.cc | 81 mutex1.Lock();
82 mutex2.Lock();
83 mutex3.Lock();
88 mutex1.Lock();
89 mutex2.Lock();
90 mutex3.Lock();
101 recursive_mutex1.Lock();
102 recursive_mutex2.Lock();
110 recursive_mutex1.Lock();
112 recursive_mutex2.Lock();
[all...] |
| /external/skia/include/core/ |
| SkOnce.h | 44 // If you've already got a lock and a flag to use, this variant lets you avoid an extra SkOnceFlag.
45 template <typename Lock>
46 inline void SkOnce(bool* done, Lock* lock, void (*f)());
48 template <typename Lock, typename Arg>
49 inline void SkOnce(bool* done, Lock* lock, void (*f)(Arg), Arg arg);
85 template <typename Lock, typename Arg>
86 static void sk_once_slow(bool* done, Lock* lock, void (*f)(Arg), Arg arg)
[all...] |
| /external/chromium_org/base/test/ |
| simple_test_clock.h | 9 #include "base/synchronization/lock.h"
34 Lock lock_;
|
| simple_test_tick_clock.h | 9 #include "base/synchronization/lock.h"
31 Lock lock_;
|
| /external/chromium_org/base/threading/ |
| thread_checker_impl.h | 9 #include "base/synchronization/lock.h"
35 mutable base::Lock lock_;
|
| /external/chromium_org/net/disk_cache/blockfile/ |
| file_lock.h | 15 // This class implements a file lock that lives on the header of a memory mapped
16 // file. This is NOT a thread related lock, it is a lock to detect corruption
18 // The lock is acquired on the constructor and released on the destructor.
22 // FileLock lock(header);
24 // // At this point the destructor is going to release the lock.
26 // It is important to perform Lock() and Unlock() operations in the right order,
27 // because otherwise the desired effect of the "lock" will not be achieved. If
29 // outside the lock.
36 virtual void Lock();
[all...] |
