#ifndef DatabaseThread_h
#define DatabaseThread_h
#include <memory>
#include <wtf/Deque.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/MessageQueue.h>
#include <wtf/RefPtr.h>
#include <wtf/Threading.h>
namespace WebCore {
class Database;
class DatabaseTask;
class DatabaseTaskSynchronizer;
class Document;
class SQLTransactionClient;
class SQLTransactionCoordinator;
class DatabaseThread : public ThreadSafeRefCounted<DatabaseThread> {
public:
static Ref<DatabaseThread> create() { return adoptRef(*new DatabaseThread); }
~DatabaseThread();
bool start();
void requestTermination(DatabaseTaskSynchronizer* cleanupSync);
bool terminationRequested(DatabaseTaskSynchronizer* = nullptr) const;
void scheduleTask(std::unique_ptr<DatabaseTask>);
void scheduleImmediateTask(std::unique_ptr<DatabaseTask>); void unscheduleDatabaseTasks(Database*);
bool hasPendingDatabaseActivity() const;
void recordDatabaseOpen(Database*);
void recordDatabaseClosed(Database*);
ThreadIdentifier getThreadID() { return m_threadID; }
SQLTransactionClient* transactionClient() { return m_transactionClient.get(); }
SQLTransactionCoordinator* transactionCoordinator() { return m_transactionCoordinator.get(); }
#if PLATFORM(IOS)
void setPaused(bool);
void handlePausedQueue();
#endif
private:
DatabaseThread();
static void databaseThreadStart(void*);
void databaseThread();
Mutex m_threadCreationMutex;
ThreadIdentifier m_threadID;
RefPtr<DatabaseThread> m_selfRef;
MessageQueue<DatabaseTask> m_queue;
#if PLATFORM(IOS)
MessageQueue<DatabaseTask> m_pausedQueue;
Mutex m_pausedMutex;
volatile bool m_paused;
#endif
typedef HashSet<RefPtr<Database>> DatabaseSet;
DatabaseSet m_openDatabaseSet;
std::unique_ptr<SQLTransactionClient> m_transactionClient;
std::unique_ptr<SQLTransactionCoordinator> m_transactionCoordinator;
DatabaseTaskSynchronizer* m_cleanupSync;
};
}
#endif // DatabaseThread_h