no bug - Bumping Firefox l10n changesets r=release a=l10n-bump DONTBUILD CLOSED TREE
[gecko.git] / storage / SQLiteMutex.h
blobb7198b1912fdc8d1182a445421aec3450474c23d
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #ifndef mozilla_storage_SQLiteMutex_h_
8 #define mozilla_storage_SQLiteMutex_h_
10 #include "mozilla/BlockingResourceBase.h"
11 #include "sqlite3.h"
13 namespace mozilla {
14 namespace storage {
16 /**
17 * Wrapper class for sqlite3_mutexes. To be used whenever we want to use a
18 * sqlite3_mutex.
20 * @warning Never EVER wrap the same sqlite3_mutex with a different SQLiteMutex.
21 * If you do this, you void the deadlock detector's warranty!
23 class SQLiteMutex : private BlockingResourceBase {
24 public:
25 /**
26 * Constructs a wrapper for a sqlite3_mutex that has deadlock detecting.
28 * @param aName
29 * A name which can be used to reference this mutex.
31 explicit SQLiteMutex(const char* aName)
32 : BlockingResourceBase(aName, eMutex), mMutex(nullptr) {}
34 /**
35 * Sets the mutex that we are wrapping. We generally do not have access to
36 * our mutex at class construction, so we have to set it once we get access to
37 * it.
39 * @param aMutex
40 * The sqlite3_mutex that we are going to wrap.
42 void initWithMutex(sqlite3_mutex* aMutex) {
43 MOZ_ASSERT(aMutex, "You must pass in a valid mutex!");
44 MOZ_ASSERT(!mMutex, "A mutex has already been set for this!");
45 mMutex = aMutex;
48 /**
49 * After a connection has been successfully closed, its mutex is a dangling
50 * pointer, and as such it should be destroyed.
52 void destroy() { mMutex = NULL; }
54 /**
55 * Acquires the mutex.
57 void lock() {
58 MOZ_ASSERT(mMutex, "No mutex associated with this wrapper!");
59 #if defined(DEBUG)
60 // While SQLite Mutexes may be recursive, in our own code we do not want to
61 // treat them as such.
62 CheckAcquire();
63 #endif
65 ::sqlite3_mutex_enter(mMutex);
67 #if defined(DEBUG)
68 Acquire(); // Call is protected by us holding the mutex.
69 #endif
72 /**
73 * Releases the mutex.
75 void unlock() {
76 MOZ_ASSERT(mMutex, "No mutex associated with this wrapper!");
77 #if defined(DEBUG)
78 // While SQLite Mutexes may be recursive, in our own code we do not want to
79 // treat them as such.
80 Release(); // Call is protected by us holding the mutex.
81 #endif
83 ::sqlite3_mutex_leave(mMutex);
86 /**
87 * Asserts that the current thread owns the mutex.
89 void assertCurrentThreadOwns() {
90 MOZ_ASSERT(mMutex, "No mutex associated with this wrapper!");
91 MOZ_ASSERT(::sqlite3_mutex_held(mMutex),
92 "Mutex is not held, but we expect it to be!");
95 /**
96 * Asserts that the current thread does not own the mutex.
98 void assertNotCurrentThreadOwns() {
99 MOZ_ASSERT(mMutex, "No mutex associated with this wrapper!");
100 MOZ_ASSERT(::sqlite3_mutex_notheld(mMutex),
101 "Mutex is held, but we expect it to not be!");
104 private:
105 sqlite3_mutex* mMutex;
109 * Automatically acquires the mutex when it enters scope, and releases it when
110 * it leaves scope.
112 class MOZ_STACK_CLASS SQLiteMutexAutoLock {
113 public:
114 explicit SQLiteMutexAutoLock(SQLiteMutex& aMutex) : mMutex(aMutex) {
115 mMutex.lock();
118 ~SQLiteMutexAutoLock() { mMutex.unlock(); }
120 private:
121 SQLiteMutex& mMutex;
125 * Automatically releases the mutex when it enters scope, and acquires it when
126 * it leaves scope.
128 class MOZ_STACK_CLASS SQLiteMutexAutoUnlock {
129 public:
130 explicit SQLiteMutexAutoUnlock(SQLiteMutex& aMutex) : mMutex(aMutex) {
131 mMutex.unlock();
134 ~SQLiteMutexAutoUnlock() { mMutex.lock(); }
136 private:
137 SQLiteMutex& mMutex;
140 } // namespace storage
141 } // namespace mozilla
143 #endif // mozilla_storage_SQLiteMutex_h_