Replace createCrossThreadTask with crossThreadBind in webdatabase

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

 /*
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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 "modules/webdatabase/Database.h"
 
+#include <memory>
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
-#include "core/dom/ExecutionContextTask.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/html/VoidCallback.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "modules/webdatabase/ChangeVersionData.h"
 #include "modules/webdatabase/ChangeVersionWrapper.h"
 #include "modules/webdatabase/DatabaseAuthorizer.h"
 #include "modules/webdatabase/DatabaseContext.h"
 #include "modules/webdatabase/DatabaseManager.h"
 #include "modules/webdatabase/DatabaseTask.h"
 #include "modules/webdatabase/DatabaseThread.h"
 #include "modules/webdatabase/DatabaseTracker.h"
 #include "modules/webdatabase/SQLError.h"
 #include "modules/webdatabase/SQLTransaction.h"
 #include "modules/webdatabase/SQLTransactionBackend.h"
 #include "modules/webdatabase/SQLTransactionCallback.h"
 #include "modules/webdatabase/SQLTransactionClient.h"
 #include "modules/webdatabase/SQLTransactionCoordinator.h"
 #include "modules/webdatabase/SQLTransactionErrorCallback.h"
 #include "modules/webdatabase/StorageLog.h"
 #include "modules/webdatabase/sqlite/SQLiteStatement.h"
 #include "modules/webdatabase/sqlite/SQLiteTransaction.h"
+#include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/heap/SafePoint.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebDatabaseObserver.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "wtf/Atomics.h"
 #include "wtf/CurrentTime.h"
-#include <memory>
 
 // Registering "opened" databases with the DatabaseTracker
 // =======================================================
 // The DatabaseTracker maintains a list of databases that have been
 // "opened" so that the client can call interrupt or delete on every database
 // associated with a DatabaseContext.
 //
 // We will only call DatabaseTracker::addOpenDatabase() to add the database
 // to the tracker as opened when we've succeeded in opening the database,
 // and will set m_opened to true. Similarly, we only call
@@ skipping 171 matching lines @@
     guidCount().add(m_guid);
   }
 
   m_filename = DatabaseManager::manager().fullPathForDatabase(
       getSecurityOrigin(), m_name);
 
   m_databaseThreadSecurityOrigin =
       m_contextThreadSecurityOrigin->isolatedCopy();
   ASSERT(m_databaseContext->databaseThread());
   ASSERT(m_databaseContext->isContextThread());
+  m_databaseTaskRunner =
+      TaskRunnerHelper::get(TaskType::DatabaseAccess, getExecutionContext());
 }
 
 Database::~Database() {
   // SQLite is "multi-thread safe", but each database handle can only be used
   // on a single thread at a time.
   //
   // For Database, we open the SQLite database on the DatabaseThread, and
   // hence we should also close it on that same thread. This means that the
   // SQLite database need to be closed by another mechanism (see
   // DatabaseContext::stopDatabases()). By the time we get here, the SQLite
@@ skipping 605 matching lines @@
   SQLTransaction* transaction = SQLTransaction::create(
       this, callback, successCallback, errorCallback, readOnly);
   SQLTransactionBackend* transactionBackend =
       runTransaction(transaction, readOnly, changeVersionData);
   if (!transactionBackend) {
     SQLTransactionErrorCallback* callback = transaction->releaseErrorCallback();
     ASSERT(callback == originalErrorCallback);
     if (callback) {
       std::unique_ptr<SQLErrorData> error = SQLErrorData::create(
           SQLError::kUnknownErr, "database has been closed");
-      TaskRunnerHelper::get(TaskType::DatabaseAccess, getExecutionContext())
-          ->postTask(BLINK_FROM_HERE, WTF::bind(&callTransactionErrorCallback,
-                                                wrapPersistent(callback),
-                                                WTF::passed(std::move(error))));
+      getDatabaseTaskRunner()->postTask(
+          BLINK_FROM_HERE,
+          WTF::bind(&callTransactionErrorCallback, wrapPersistent(callback),
+                    WTF::passed(std::move(error))));
     }
   }
 }
 
 void Database::scheduleTransactionCallback(SQLTransaction* transaction) {
   // The task is constructed in a database thread, and destructed in the
   // context thread.
-  getExecutionContext()->postTask(
-      TaskType::DatabaseAccess, BLINK_FROM_HERE,
-      createCrossThreadTask(&SQLTransaction::performPendingCallback,
-                            wrapCrossThreadPersistent(transaction)));
+  getDatabaseTaskRunner()->postTask(
+      BLINK_FROM_HERE, crossThreadBind(&SQLTransaction::performPendingCallback,
+                                       wrapCrossThreadPersistent(transaction)));
 }
 
 Vector<String> Database::performGetTableNames() {
   disableAuthorizer();
 
   SQLiteStatement statement(
       sqliteDatabase(), "SELECT name FROM sqlite_master WHERE type='table';");
   if (statement.prepare() != SQLResultOk) {
     DLOG(ERROR) << "Unable to retrieve list of tables for database "
                 << databaseDebugName();
@@ skipping 43 matching lines @@
     return m_contextThreadSecurityOrigin.get();
   if (getDatabaseContext()->databaseThread()->isDatabaseThread())
     return m_databaseThreadSecurityOrigin.get();
   return nullptr;
 }
 
 bool Database::opened() {
   return static_cast<bool>(acquireLoad(&m_opened));
 }
 
+WebTaskRunner* Database::getDatabaseTaskRunner() const {
+  return m_databaseTaskRunner.get();
+}
+
 }  // namespace blink