| /external/chromium/crypto/ |
| mac_security_services_lock.h | 10 class Lock;
21 base::Lock& GetMacSecurityServicesLock();
|
| mac_security_services_lock.cc | 8 #include "base/synchronization/lock.h"
21 base::Lock& lock() { return lock_; } function in class:__anon4836::SecurityServicesSingleton
29 base::Lock lock_;
38 base::Lock& GetMacSecurityServicesLock() {
39 return SecurityServicesSingleton::GetInstance()->lock();
|
| nss_util.h | 17 class Lock;
133 // writes to the NSS databases with a global lock. The lock is hidden beneath a
138 base::Lock* GetNSSWriteLock();
140 // A helper class that acquires the NSS write Lock while the AutoNSSWriteLock
147 base::Lock *lock_;
|
| capi_util.cc | 9 #include "base/synchronization/lock.h"
19 // Returns a lock to guard calls to CryptAcquireContext with
21 base::Lock& acquire_context_lock() {
31 base::Lock acquire_context_lock_;
45 base::AutoLock lock(CAPIUtilSingleton::GetInstance()->acquire_context_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
|
| /external/chromium/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_() {
21 void Lock::AssertAcquired() const {
26 void Lock::CheckHeldAndUnmark() {
33 void Lock::CheckUnheldAndMark() {
|
| lock.h | 18 class BASE_API Lock {
21 Lock() : lock_() {}
22 ~Lock() {}
23 void Acquire() { lock_.Lock(); }
26 // If the lock is not held, take it and return true. If the lock is already
28 // by a thread already holding the lock (what happens is undefined and an
35 Lock();
36 ~Lock() {}
40 // acquire the lock a second time (while already holding it)
[all...] |
| lock_unittest.cc | 7 #include "base/synchronization/lock.h"
17 BasicLockTestThread(Lock* lock) : lock_(lock), acquired_(0) {}
43 Lock* lock_;
50 Lock lock; local
51 BasicLockTestThread thread(&lock);
58 lock.Acquire();
60 lock.Release()
110 Lock lock; local
175 Lock lock; local
191 Lock lock; local
[all...] |
| condition_variable.h | 79 #include "base/synchronization/lock.h"
87 // Construct a cv for use with ONLY one user lock.
88 explicit ConditionVariable(Lock* user_lock);
109 // All calls to methods MUST be done under protection of a lock so that links
110 // can be validated. Without the lock, some links might asynchronously
160 base::Lock internal_lock_;
162 // Lock that is acquired before calling Wait().
163 base::Lock& user_lock_;
180 base::Lock* user_lock_; // Needed to adjust shadow lock state on wait
[all...] |
| lock_impl_win.cc | 27 void LockImpl::Lock() {
|
| /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/valgrind/unittest/ |
| deadlock_unittest.cc | 80 mu[idx].Lock();
91 mu[idx].Lock();
141 mu.Lock();
165 mu1.Lock();
166 mu2.Lock();
172 mu2.Lock();
173 mu1.Lock();
190 mu1.Lock(); mu2.Lock();
195 mu2.Lock(); mu3.Lock()
[all...] |
| /external/chromium/base/threading/ |
| thread_checker_impl.h | 10 #include "base/synchronization/lock.h"
36 mutable base::Lock lock_;
|
| /external/chromium/net/disk_cache/ |
| file_lock.cc | 15 void FileLock::Lock() {
|
| 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.
37 virtual void Lock();
[all...] |
| /ndk/sources/cxx-stl/llvm-libc++/test/thread/thread.condition/thread.condition.condvar/ |
| destructor.pass.cpp | 23 typedef std::unique_lock<std::mutex> Lock;
30 Lock lk(m);
38 Lock lk(m);
49 Lock lk(m);
|
| /external/valgrind/main/helgrind/ |
| hg_lock_n_thread.h | 50 encode lock-sets in libhb's history records (Thr_n_RCEC). */
89 WordSetID locksetA; /* WordSet of Lock* currently held by thread */
103 /* Stores information about a lock's current state. These are
106 contains Lock*s. Solution is to copy any Lock which is to be
108 'normal' collection of Locks, which can come and go. When the lock
112 /* Lock kinds. */
117 LK_rdwr /* reader-writer lock */
129 /* Place where lock first came to the attention of Helgrind. */
131 /* If the lock is held, place where the lock most recently mad
[all...] |
| /external/compiler-rt/lib/tsan/rtl/ |
| tsan_mutex.h | 44 void Lock();
65 typedef GenericScopedLock<Mutex> Lock;
71 void Lock(MutexType t);
|
| /external/llvm/lib/Support/ |
| PluginLoader.cpp | 27 sys::SmartScopedLock<true> Lock(*PluginsLock);
38 sys::SmartScopedLock<true> Lock(*PluginsLock);
43 sys::SmartScopedLock<true> Lock(*PluginsLock);
|
| /bionic/libc/bionic/ |
| pthread_accessor.h | 27 Lock();
55 void Lock() {
|
| /external/regex-re2/util/ |
| mutex.h | 19 typedef int MutexType; // to keep a lock-count
58 inline void Lock(); // Block if needed until free then acquire exclusively
59 inline void Unlock(); // Release a lock acquired via Lock()
60 inline bool TryLock(); // If free, Lock() and return true, else return false
62 // be implemented as synonyms to Lock() and Unlock(). So you can use
67 inline void WriterLock() { Lock(); } // Acquire an exclusive lock
68 inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()
88 // writing and a number > 0 when reading (and 0 when no lock is held)
[all...] |
| /development/host/windows/usb/api/ |
| adb_api_instance.cpp | 36 adb_app_instance_map_locker.Lock();
|
| /external/chromium/base/third_party/dmg_fp/ |
| dtoa_wrapper.cc | 7 #include "base/synchronization/lock.h"
11 // A single lock would lead to an attempted recursive grab.
12 static base::Lock dtoa_locks[2];
21 * by FREE_DTOA_LOCK(n) for n = 0 or 1. (The second lock, accessed
23 * powers of 5; omitting this lock would introduce a small
|
| /external/chromium/chrome/browser/importer/ |
| firefox_profile_lock_win.cc | 58 void FirefoxProfileLock::Lock() {
|
