Rename DatabaseTaskSynchronizer to TaskSynchronizer and move it to platform/

- We want to use DatabaseTaskSynchronizer in the HTML parser thread in a follow-up CL. In preparation for that, this CL renames DatabaseTaskSynchronizer to TaskSynchronizer and moves it to platform/.

BUG=340522
R=ager@chromium.org, tkent@chromium.org, wibling@chromium.org

Committed: https://src.chromium.org/viewvc/blink?view=rev&revision=170532

Review URL: https://codereview.chromium.org/198673002

git-svn-id: svn://svn.chromium.org/blink/trunk@170536 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/modules/webdatabase/Database.cpp

@@ -219,7 +219,7 @@ Vector<String> Database::tableNames()
     // FIXME: Not using isolatedCopy on these strings looks ok since threads take strict turns
     // in dealing with them. However, if the code changes, this may not be true anymore.
     Vector<String> result;
-    DatabaseTaskSynchronizer synchronizer;
+    TaskSynchronizer synchronizer;
     if (!databaseContext()->databaseThread() || databaseContext()->databaseThread()->terminationRequested(&synchronizer))
         return result;
 

third_party/WebKit/Source/modules/webdatabase/DatabaseBackend.cpp

@@ -55,7 +55,7 @@ void DatabaseBackend::trace(Visitor* visitor)
 
 bool DatabaseBackend::openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
 {
-    DatabaseTaskSynchronizer synchronizer;
+    TaskSynchronizer synchronizer;
     if (!databaseContext()->databaseThread() || databaseContext()->databaseThread()->terminationRequested(&synchronizer))
         return false;
 

third_party/WebKit/Source/modules/webdatabase/DatabaseContext.cpp

@@ -239,7 +239,7 @@ void DatabaseContext::stopDatabases()
     // DatabaseThread.
 
     if (m_databaseThread && !m_hasRequestedTermination) {
-        DatabaseTaskSynchronizer sync;
+        TaskSynchronizer sync;
         m_databaseThread->requestTermination(&sync);
         m_hasRequestedTermination = true;
         sync.waitForTaskCompletion();

third_party/WebKit/Source/modules/webdatabase/DatabaseContext.h

@@ -38,7 +38,7 @@ namespace WebCore {
 class Database;
 class DatabaseBackendBase;
 class DatabaseContext;
-class DatabaseTaskSynchronizer;
+class TaskSynchronizer;
 class DatabaseThread;
 class ExecutionContext;
 class SecurityOrigin;

third_party/WebKit/Source/modules/webdatabase/DatabaseManager.h

@@ -43,7 +43,7 @@ class DatabaseBackendBase;
 class DatabaseCallback;
 class DatabaseContext;
 class DatabaseSync;
-class DatabaseTaskSynchronizer;
+class TaskSynchronizer;
 class ExceptionState;
 class SecurityOrigin;
 class ExecutionContext;

third_party/WebKit/Source/modules/webdatabase/DatabaseTask.cpp

@@ -25,6 +25,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 #include "modules/webdatabase/DatabaseTask.h"
 
@@ -35,34 +36,7 @@
 
 namespace WebCore {
 
-DatabaseTaskSynchronizer::DatabaseTaskSynchronizer()
-    : m_taskCompleted(false)
-#ifndef NDEBUG
-    , m_hasCheckedForTermination(false)
-#endif
-{
-}
-
-void DatabaseTaskSynchronizer::waitForTaskCompletion()
-{
-    // Prevent the deadlock between park request by other threads and blocking
-    // by m_synchronousCondition.
-    ThreadState::SafePointScope scope(ThreadState::HeapPointersOnStack);
-    m_synchronousMutex.lock();
-    while (!m_taskCompleted)
-        m_synchronousCondition.wait(m_synchronousMutex);
-    m_synchronousMutex.unlock();
-}
-
-void DatabaseTaskSynchronizer::taskCompleted()
-{
-    m_synchronousMutex.lock();
-    m_taskCompleted = true;
-    m_synchronousCondition.signal();
-    m_synchronousMutex.unlock();
-}
-
-DatabaseTask::DatabaseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
+DatabaseTask::DatabaseTask(DatabaseBackend* database, TaskSynchronizer* synchronizer)
     : m_database(database)
     , m_synchronizer(synchronizer)
 #if !LOG_DISABLED
@@ -109,7 +83,7 @@ void DatabaseTask::run()
 // *** DatabaseOpenTask ***
 // Opens the database file and verifies the version matches the expected version.
 
-DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask(DatabaseBackend* database, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
+DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask(DatabaseBackend* database, bool setVersionInNewDatabase, TaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
     : DatabaseTask(database, synchronizer)
     , m_setVersionInNewDatabase(setVersionInNewDatabase)
     , m_error(error)
@@ -137,7 +111,7 @@ const char* DatabaseBackend::DatabaseOpenTask::debugTaskName() const
 // *** DatabaseCloseTask ***
 // Closes the database.
 
-DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
+DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask(DatabaseBackend* database, TaskSynchronizer* synchronizer)
     : DatabaseTask(database, synchronizer)
 {
 }
@@ -195,7 +169,7 @@ const char* DatabaseBackend::DatabaseTransactionTask::debugTaskName() const
 // *** DatabaseTableNamesTask ***
 // Retrieves a list of all tables in the database - for WebInspector support.
 
-DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
+DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask(DatabaseBackend* database, TaskSynchronizer* synchronizer, Vector<String>& names)
     : DatabaseTask(database, synchronizer)
     , m_tableNames(names)
 {

third_party/WebKit/Source/modules/webdatabase/DatabaseTask.h

@@ -25,6 +25,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #ifndef DatabaseTask_h
 #define DatabaseTask_h
 
@@ -34,6 +35,7 @@
 #include "modules/webdatabase/DatabaseError.h"
 #include "modules/webdatabase/SQLTransactionBackend.h"
 #include "platform/Task.h"
+#include "platform/TaskSynchronizer.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
@@ -44,33 +46,6 @@
 
 namespace WebCore {
 
-// Can be used to wait until DatabaseTask is completed.
-// Has to be passed into DatabaseTask::create to be associated with the task.
-class DatabaseTaskSynchronizer {
-    WTF_MAKE_NONCOPYABLE(DatabaseTaskSynchronizer);
-public:
-    DatabaseTaskSynchronizer();
-
-    // Called from main thread to wait until task is completed.
-    void waitForTaskCompletion();
-
-    // Called by the task.
-    void taskCompleted();
-
-#ifndef NDEBUG
-    bool hasCheckedForTermination() const { return m_hasCheckedForTermination; }
-    void setHasCheckedForTermination() { m_hasCheckedForTermination = true; }
-#endif
-
-private:
-    bool m_taskCompleted;
-    Mutex m_synchronousMutex;
-    ThreadCondition m_synchronousCondition;
-#ifndef NDEBUG
-    bool m_hasCheckedForTermination;
-#endif
-};
-
 class DatabaseTask : public blink::WebThread::Task {
     WTF_MAKE_NONCOPYABLE(DatabaseTask); WTF_MAKE_FAST_ALLOCATED;
 public:
@@ -85,14 +60,14 @@ public:
 #endif
 
 protected:
-    DatabaseTask(DatabaseBackend*, DatabaseTaskSynchronizer*);
+    DatabaseTask(DatabaseBackend*, TaskSynchronizer*);
 
 private:
     virtual void doPerformTask() = 0;
     virtual void taskCancelled() { }
 
     RefPtrWillBeCrossThreadPersistent<DatabaseBackend> m_database;
-    DatabaseTaskSynchronizer* m_synchronizer;
+    TaskSynchronizer* m_synchronizer;
 
 #if !LOG_DISABLED
     virtual const char* debugTaskName() const = 0;
@@ -102,13 +77,13 @@ private:
 
 class DatabaseBackend::DatabaseOpenTask FINAL : public DatabaseTask {
 public:
-    static PassOwnPtr<DatabaseOpenTask> create(DatabaseBackend* db, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
+    static PassOwnPtr<DatabaseOpenTask> create(DatabaseBackend* db, bool setVersionInNewDatabase, TaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
     {
         return adoptPtr(new DatabaseOpenTask(db, setVersionInNewDatabase, synchronizer, error, errorMessage, success));
     }
 
 private:
-    DatabaseOpenTask(DatabaseBackend*, bool setVersionInNewDatabase, DatabaseTaskSynchronizer*, DatabaseError&, String& errorMessage, bool& success);
+    DatabaseOpenTask(DatabaseBackend*, bool setVersionInNewDatabase, TaskSynchronizer*, DatabaseError&, String& errorMessage, bool& success);
 
     virtual void doPerformTask() OVERRIDE;
 #if !LOG_DISABLED
@@ -123,13 +98,13 @@ private:
 
 class DatabaseBackend::DatabaseCloseTask FINAL : public DatabaseTask {
 public:
-    static PassOwnPtr<DatabaseCloseTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer)
+    static PassOwnPtr<DatabaseCloseTask> create(DatabaseBackend* db, TaskSynchronizer* synchronizer)
     {
         return adoptPtr(new DatabaseCloseTask(db, synchronizer));
     }
 
 private:
-    DatabaseCloseTask(DatabaseBackend*, DatabaseTaskSynchronizer*);
+    DatabaseCloseTask(DatabaseBackend*, TaskSynchronizer*);
 
     virtual void doPerformTask() OVERRIDE;
 #if !LOG_DISABLED
@@ -163,13 +138,13 @@ private:
 
 class DatabaseBackend::DatabaseTableNamesTask FINAL : public DatabaseTask {
 public:
-    static PassOwnPtr<DatabaseTableNamesTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
+    static PassOwnPtr<DatabaseTableNamesTask> create(DatabaseBackend* db, TaskSynchronizer* synchronizer, Vector<String>& names)
     {
         return adoptPtr(new DatabaseTableNamesTask(db, synchronizer, names));
     }
 
 private:
-    DatabaseTableNamesTask(DatabaseBackend*, DatabaseTaskSynchronizer*, Vector<String>& names);
+    DatabaseTableNamesTask(DatabaseBackend*, TaskSynchronizer*, Vector<String>& names);
 
     virtual void doPerformTask() OVERRIDE;
 #if !LOG_DISABLED

third_party/WebKit/Source/modules/webdatabase/DatabaseThread.cpp

@@ -83,7 +83,7 @@ void DatabaseThread::setupDatabaseThread()
     ThreadState::current()->addInterruptor(m_messageLoopInterruptor.get());
 }
 
-void DatabaseThread::requestTermination(DatabaseTaskSynchronizer *cleanupSync)
+void DatabaseThread::requestTermination(TaskSynchronizer *cleanupSync)
 {
     MutexLocker lock(m_terminationRequestedMutex);
     ASSERT(!m_terminationRequested);
@@ -93,7 +93,7 @@ void DatabaseThread::requestTermination(DatabaseTaskSynchronizer *cleanupSync)
     m_thread->postTask(new Task(WTF::bind(&DatabaseThread::cleanupDatabaseThread, this)));
 }
 
-bool DatabaseThread::terminationRequested(DatabaseTaskSynchronizer* taskSynchronizer) const
+bool DatabaseThread::terminationRequested(TaskSynchronizer* taskSynchronizer) const
 {
 #ifndef NDEBUG
     if (taskSynchronizer)

third_party/WebKit/Source/modules/webdatabase/DatabaseThread.h

@@ -44,12 +44,12 @@ namespace WebCore {
 
 class DatabaseBackend;
 class DatabaseTask;
-class DatabaseTaskSynchronizer;
 class Document;
 class MessageLoopInterruptor;
 class PendingGCRunner;
 class SQLTransactionClient;
 class SQLTransactionCoordinator;
+class TaskSynchronizer;
 
 class DatabaseThread : public ThreadSafeRefCountedWillBeGarbageCollectedFinalized<DatabaseThread> {
 public:
@@ -58,8 +58,8 @@ public:
     void trace(Visitor*);
 
     void start();
-    void requestTermination(DatabaseTaskSynchronizer* cleanupSync);
-    bool terminationRequested(DatabaseTaskSynchronizer* taskSynchronizer = 0) const;
+    void requestTermination(TaskSynchronizer* cleanupSync);
+    bool terminationRequested(TaskSynchronizer* = 0) const;
 
     void scheduleTask(PassOwnPtr<DatabaseTask>);
 
@@ -88,7 +88,7 @@ private:
 
     OwnPtr<SQLTransactionClient> m_transactionClient;
     OwnPtrWillBeMember<SQLTransactionCoordinator> m_transactionCoordinator;
-    DatabaseTaskSynchronizer* m_cleanupSync;
+    TaskSynchronizer* m_cleanupSync;
 
     mutable Mutex m_terminationRequestedMutex;
     bool m_terminationRequested;

third_party/WebKit/Source/platform/TaskSynchronizer.cpp

@@ -25,17 +25,15 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
-#include "modules/webdatabase/DatabaseTask.h"
+#include "platform/TaskSynchronizer.h"
 
-#include "platform/Logging.h"
-#include "modules/webdatabase/Database.h"
-#include "modules/webdatabase/DatabaseContext.h"
-#include "modules/webdatabase/DatabaseThread.h"
+#include "heap/ThreadState.h"
 
 namespace WebCore {
 
-DatabaseTaskSynchronizer::DatabaseTaskSynchronizer()
+TaskSynchronizer::TaskSynchronizer()
     : m_taskCompleted(false)
 #ifndef NDEBUG
     , m_hasCheckedForTermination(false)
@@ -43,7 +41,7 @@ DatabaseTaskSynchronizer::DatabaseTaskSynchronizer()
 {
 }
 
-void DatabaseTaskSynchronizer::waitForTaskCompletion()
+void TaskSynchronizer::waitForTaskCompletion()
 {
     // Prevent the deadlock between park request by other threads and blocking
     // by m_synchronousCondition.
@@ -54,7 +52,7 @@ void DatabaseTaskSynchronizer::waitForTaskCompletion()
     m_synchronousMutex.unlock();
 }
 
-void DatabaseTaskSynchronizer::taskCompleted()
+void TaskSynchronizer::taskCompleted()
 {
     m_synchronousMutex.lock();
     m_taskCompleted = true;
@@ -62,156 +60,4 @@ void DatabaseTaskSynchronizer::taskCompleted()
     m_synchronousMutex.unlock();
 }
 
-DatabaseTask::DatabaseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
-    : m_database(database)
-    , m_synchronizer(synchronizer)
-#if !LOG_DISABLED
-    , m_complete(false)
-#endif
-{
-}
-
-DatabaseTask::~DatabaseTask()
-{
-#if !LOG_DISABLED
-    ASSERT(m_complete || !m_synchronizer);
-#endif
-}
-
-void DatabaseTask::run()
-{
-    // Database tasks are meant to be used only once, so make sure this one hasn't been performed before.
-#if !LOG_DISABLED
-    ASSERT(!m_complete);
-#endif
-
-    if (!m_synchronizer && !m_database->databaseContext()->databaseThread()->isDatabaseOpen(m_database.get())) {
-        taskCancelled();
-#if !LOG_DISABLED
-        m_complete = true;
-#endif
-        return;
-    }
-
-    WTF_LOG(StorageAPI, "Performing %s %p\n", debugTaskName(), this);
-
-    m_database->resetAuthorizer();
-    doPerformTask();
-
-    if (m_synchronizer)
-        m_synchronizer->taskCompleted();
-
-#if !LOG_DISABLED
-    m_complete = true;
-#endif
-}
-
-// *** DatabaseOpenTask ***
-// Opens the database file and verifies the version matches the expected version.
-
-DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask(DatabaseBackend* database, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
-    : DatabaseTask(database, synchronizer)
-    , m_setVersionInNewDatabase(setVersionInNewDatabase)
-    , m_error(error)
-    , m_errorMessage(errorMessage)
-    , m_success(success)
-{
-    ASSERT(synchronizer); // A task with output parameters is supposed to be synchronous.
-}
-
-void DatabaseBackend::DatabaseOpenTask::doPerformTask()
-{
-    String errorMessage;
-    m_success = database()->performOpenAndVerify(m_setVersionInNewDatabase, m_error, errorMessage);
-    if (!m_success)
-        m_errorMessage = errorMessage.isolatedCopy();
-}
-
-#if !LOG_DISABLED
-const char* DatabaseBackend::DatabaseOpenTask::debugTaskName() const
-{
-    return "DatabaseOpenTask";
-}
-#endif
-
-// *** DatabaseCloseTask ***
-// Closes the database.
-
-DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
-    : DatabaseTask(database, synchronizer)
-{
-}
-
-void DatabaseBackend::DatabaseCloseTask::doPerformTask()
-{
-    Database::from(database())->close();
-}
-
-#if !LOG_DISABLED
-const char* DatabaseBackend::DatabaseCloseTask::debugTaskName() const
-{
-    return "DatabaseCloseTask";
-}
-#endif
-
-// *** DatabaseTransactionTask ***
-// Starts a transaction that will report its results via a callback.
-
-DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtrWillBeRawPtr<SQLTransactionBackend> transaction)
-    : DatabaseTask(Database::from(transaction->database()), 0)
-    , m_transaction(transaction)
-{
-}
-
-DatabaseBackend::DatabaseTransactionTask::~DatabaseTransactionTask()
-{
-}
-
-void DatabaseBackend::DatabaseTransactionTask::doPerformTask()
-{
-    m_transaction->performNextStep();
-}
-
-void DatabaseBackend::DatabaseTransactionTask::taskCancelled()
-{
-    // If the task is being destructed without the transaction ever being run,
-    // then we must either have an error or an interruption. Give the
-    // transaction a chance to clean up since it may not have been able to
-    // run to its clean up state.
-
-    // Transaction phase 2 cleanup. See comment on "What happens if a
-    // transaction is interrupted?" at the top of SQLTransactionBackend.cpp.
-
-    m_transaction->notifyDatabaseThreadIsShuttingDown();
-}
-
-#if !LOG_DISABLED
-const char* DatabaseBackend::DatabaseTransactionTask::debugTaskName() const
-{
-    return "DatabaseTransactionTask";
-}
-#endif
-
-// *** DatabaseTableNamesTask ***
-// Retrieves a list of all tables in the database - for WebInspector support.
-
-DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
-    : DatabaseTask(database, synchronizer)
-    , m_tableNames(names)
-{
-    ASSERT(synchronizer); // A task with output parameters is supposed to be synchronous.
-}
-
-void DatabaseBackend::DatabaseTableNamesTask::doPerformTask()
-{
-    m_tableNames = Database::from(database())->performGetTableNames();
-}
-
-#if !LOG_DISABLED
-const char* DatabaseBackend::DatabaseTableNamesTask::debugTaskName() const
-{
-    return "DatabaseTableNamesTask";
-}
-#endif
-
 } // namespace WebCore

third_party/WebKit/Source/platform/TaskSynchronizer.h

@@ -25,36 +25,27 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#ifndef DatabaseTask_h
-#define DatabaseTask_h
 
-#include "heap/Handle.h"
-#include "modules/webdatabase/DatabaseBackend.h"
-#include "modules/webdatabase/DatabaseBasicTypes.h"
-#include "modules/webdatabase/DatabaseError.h"
-#include "modules/webdatabase/SQLTransactionBackend.h"
-#include "platform/Task.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
-#include "wtf/PassRefPtr.h"
-#include "wtf/RefPtr.h"
+#ifndef TaskSynchronizer_h
+#define TaskSynchronizer_h
+
+#include "platform/PlatformExport.h"
+#include "wtf/Noncopyable.h"
 #include "wtf/Threading.h"
-#include "wtf/Vector.h"
-#include "wtf/text/WTFString.h"
+#include "wtf/ThreadingPrimitives.h"
 
 namespace WebCore {
 
-// Can be used to wait until DatabaseTask is completed.
-// Has to be passed into DatabaseTask::create to be associated with the task.
-class DatabaseTaskSynchronizer {
-    WTF_MAKE_NONCOPYABLE(DatabaseTaskSynchronizer);
+// TaskSynchronizer can be used to wait for task completion.
+class PLATFORM_EXPORT TaskSynchronizer {
+    WTF_MAKE_NONCOPYABLE(TaskSynchronizer);
 public:
-    DatabaseTaskSynchronizer();
+    TaskSynchronizer();
 
-    // Called from main thread to wait until task is completed.
+    // Called from a thread that waits for the task completion.
     void waitForTaskCompletion();
 
-    // Called by the task.
+    // Called from a thread that executes the task.
     void taskCompleted();
 
 #ifndef NDEBUG
@@ -71,114 +62,6 @@ private:
 #endif
 };
 
-class DatabaseTask : public blink::WebThread::Task {
-    WTF_MAKE_NONCOPYABLE(DatabaseTask); WTF_MAKE_FAST_ALLOCATED;
-public:
-    virtual ~DatabaseTask();
-
-    virtual void run() OVERRIDE FINAL;
-
-    DatabaseBackend* database() const { return m_database.get(); }
-#ifndef NDEBUG
-    bool hasSynchronizer() const { return m_synchronizer; }
-    bool hasCheckedForTermination() const { return m_synchronizer->hasCheckedForTermination(); }
-#endif
-
-protected:
-    DatabaseTask(DatabaseBackend*, DatabaseTaskSynchronizer*);
-
-private:
-    virtual void doPerformTask() = 0;
-    virtual void taskCancelled() { }
-
-    RefPtrWillBeCrossThreadPersistent<DatabaseBackend> m_database;
-    DatabaseTaskSynchronizer* m_synchronizer;
-
-#if !LOG_DISABLED
-    virtual const char* debugTaskName() const = 0;
-    bool m_complete;
-#endif
-};
-
-class DatabaseBackend::DatabaseOpenTask FINAL : public DatabaseTask {
-public:
-    static PassOwnPtr<DatabaseOpenTask> create(DatabaseBackend* db, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
-    {
-        return adoptPtr(new DatabaseOpenTask(db, setVersionInNewDatabase, synchronizer, error, errorMessage, success));
-    }
-
-private:
-    DatabaseOpenTask(DatabaseBackend*, bool setVersionInNewDatabase, DatabaseTaskSynchronizer*, DatabaseError&, String& errorMessage, bool& success);
-
-    virtual void doPerformTask() OVERRIDE;
-#if !LOG_DISABLED
-    virtual const char* debugTaskName() const OVERRIDE;
-#endif
-
-    bool m_setVersionInNewDatabase;
-    DatabaseError& m_error;
-    String& m_errorMessage;
-    bool& m_success;
-};
-
-class DatabaseBackend::DatabaseCloseTask FINAL : public DatabaseTask {
-public:
-    static PassOwnPtr<DatabaseCloseTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer)
-    {
-        return adoptPtr(new DatabaseCloseTask(db, synchronizer));
-    }
-
-private:
-    DatabaseCloseTask(DatabaseBackend*, DatabaseTaskSynchronizer*);
-
-    virtual void doPerformTask() OVERRIDE;
-#if !LOG_DISABLED
-    virtual const char* debugTaskName() const OVERRIDE;
-#endif
-};
-
-class DatabaseBackend::DatabaseTransactionTask FINAL : public DatabaseTask {
-public:
-    virtual ~DatabaseTransactionTask();
-
-    // Transaction task is never synchronous, so no 'synchronizer' parameter.
-    static PassOwnPtr<DatabaseTransactionTask> create(PassRefPtrWillBeRawPtr<SQLTransactionBackend> transaction)
-    {
-        return adoptPtr(new DatabaseTransactionTask(transaction));
-    }
-
-    SQLTransactionBackend* transaction() const { return m_transaction.get(); }
-
-private:
-    explicit DatabaseTransactionTask(PassRefPtrWillBeRawPtr<SQLTransactionBackend>);
-
-    virtual void doPerformTask() OVERRIDE;
-    virtual void taskCancelled() OVERRIDE;
-#if !LOG_DISABLED
-    virtual const char* debugTaskName() const OVERRIDE;
-#endif
-
-    RefPtrWillBeCrossThreadPersistent<SQLTransactionBackend> m_transaction;
-};
-
-class DatabaseBackend::DatabaseTableNamesTask FINAL : public DatabaseTask {
-public:
-    static PassOwnPtr<DatabaseTableNamesTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
-    {
-        return adoptPtr(new DatabaseTableNamesTask(db, synchronizer, names));
-    }
-
-private:
-    DatabaseTableNamesTask(DatabaseBackend*, DatabaseTaskSynchronizer*, Vector<String>& names);
-
-    virtual void doPerformTask() OVERRIDE;
-#if !LOG_DISABLED
-    virtual const char* debugTaskName() const OVERRIDE;
-#endif
-
-    Vector<String>& m_tableNames;
-};
-
 } // namespace WebCore
 
-#endif // DatabaseTask_h
+#endif // TaskSynchronizer_h

third_party/WebKit/Source/platform/blink_platform.gyp

@@ -40,6 +40,7 @@
     'variables': { 'enable_wexit_time_destructors': 1 },
     'dependencies': [
       '../config.gyp:config',
+      '../heap/blink_heap.gyp:blink_heap',
       '../wtf/wtf.gyp:wtf',
       # FIXME: Can we remove the dependency on Skia?
       '<(DEPTH)/skia/skia.gyp:skia',
@@ -125,6 +126,7 @@
     'type': '<(component)',
     'dependencies': [
       '../config.gyp:config',
+      '../heap/blink_heap.gyp:blink_heap',
       '../wtf/wtf.gyp:wtf',
       'blink_common',
       'blink_prerequisites',

third_party/WebKit/Source/platform/blink_platform.gypi

@@ -126,6 +126,8 @@
       'StorageQuotaCallbacks.h',
       'Supplementable.h',
       'Task.h',
+      'TaskSynchronizer.cpp',
+      'TaskSynchronizer.h',
       'ThemeTypes.h',
       'Theme.cpp',
       'Theme.h',