Changeset 64334 in webkit


Ignore:
Timestamp:
Jul 29, 2010 10:09:47 PM (14 years ago)
Author:
commit-queue@webkit.org
Message:

2010-07-29 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r64313.
​http://trac.webkit.org/changeset/64313
​https://bugs.webkit.org/show_bug.cgi?id=43233

Some Chromium bots are not happy with it for some unknown
reason. (Requested by dumi on #webkit).

  • JavaScriptCore.exp:
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
  • wtf/Threading.h:
  • wtf/ThreadingPthreads.cpp:
  • wtf/ThreadingWin.cpp:
  • wtf/gtk/ThreadingGtk.cpp:
  • wtf/qt/ThreadingQt.cpp:

2010-07-29 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r64313.
​http://trac.webkit.org/changeset/64313
​https://bugs.webkit.org/show_bug.cgi?id=43233

Some Chromium bots are not happy with it for some unknown
reason. (Requested by dumi on #webkit).

  • fast/workers/storage/interrupt-database-expected.txt: Removed.
  • fast/workers/storage/interrupt-database-sync-expected.txt: Removed.
  • fast/workers/storage/interrupt-database-sync.html: Removed.
  • fast/workers/storage/interrupt-database.html: Removed.
  • fast/workers/storage/resources/interrupt-database-sync.js: Removed.
  • fast/workers/storage/resources/interrupt-database.js: Removed.

2010-07-29 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r64313.
​http://trac.webkit.org/changeset/64313
​https://bugs.webkit.org/show_bug.cgi?id=43233

Some Chromium bots are not happy with it for some unknown
reason. (Requested by dumi on #webkit).

  • bindings/js/JSCustomVoidCallback.cpp: (WebCore::JSCustomVoidCallback::~JSCustomVoidCallback):
  • bindings/scripts/CodeGeneratorJS.pm:
  • bindings/scripts/test/JS/JSTestCallback.cpp: (WebCore::JSTestCallback::~JSTestCallback):
  • platform/sql/SQLiteDatabase.cpp: (WebCore::SQLiteDatabase::SQLiteDatabase): (WebCore::SQLiteDatabase::close): (WebCore::SQLiteDatabase::lock): (WebCore::SQLiteDatabase::unlock):
  • platform/sql/SQLiteDatabase.h:
  • platform/sql/SQLiteStatement.cpp: (WebCore::SQLiteStatement::prepare): (WebCore::SQLiteStatement::step):
  • storage/AbstractDatabase.cpp:
  • storage/AbstractDatabase.h:
  • storage/DatabaseTracker.cpp:
  • storage/DatabaseTracker.h:
  • storage/SQLStatement.cpp: (WebCore::SQLStatement::execute):
  • storage/SQLStatementSync.cpp: (WebCore::SQLStatementSync::execute):
  • storage/SQLTransaction.cpp: (WebCore::SQLTransaction::checkAndHandleClosedDatabase): (WebCore::SQLTransaction::performNextStep): (WebCore::SQLTransaction::performPendingCallback): (WebCore::SQLTransaction::deliverTransactionCallback): (WebCore::SQLTransaction::postflightAndCommit): (WebCore::SQLTransaction::deliverTransactionErrorCallback): (WebCore::SQLTransaction::cleanupAfterTransactionErrorCallback):
  • storage/SQLTransaction.h:
  • storage/chromium/DatabaseTrackerChromium.cpp:
  • workers/WorkerThread.cpp: (WebCore::WorkerThread::stop):
Location:
trunk
Files:
6 deleted
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r64327 r64334  
     12010-07-29  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r64313.
     4        http://trac.webkit.org/changeset/64313
     5        https://bugs.webkit.org/show_bug.cgi?id=43233
     6
     7        Some Chromium bots are not happy with it for some unknown
     8        reason. (Requested by dumi on #webkit).
     9
     10        * JavaScriptCore.exp:
     11        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
     12        * wtf/Threading.h:
     13        * wtf/ThreadingPthreads.cpp:
     14        * wtf/ThreadingWin.cpp:
     15        * wtf/gtk/ThreadingGtk.cpp:
     16        * wtf/qt/ThreadingQt.cpp:
     17
    1182010-07-29  Sheriff Bot  <webkit.review.bot@gmail.com>
    219

  • trunk/JavaScriptCore/JavaScriptCore.exp

    r64313 r64334  
    368368__ZN3WTF5MutexC1Ev
    369369__ZN3WTF5MutexD1Ev
    370 __ZN3WTF5yieldEv
    371370__ZN3WTF6strtodEPKcPPc
    372371__ZN3WTF7CString11mutableDataEv

  • trunk/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

    r64313 r64334  
    331331    ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z
    332332    ?writable@PropertyDescriptor@JSC@@QBE_NXZ
    333     ?yield@WTF@@YAXXZ
    334333    WTFLog
    335334    WTFLogVerbose

  • trunk/JavaScriptCore/wtf/Threading.h

    r64313 r64334  
    102102void detachThread(ThreadIdentifier);
    103103
    104 void yield();
    105104
    106105void lockAtomicallyInitializedStaticMutex();
    … …  
    114113using WTF::detachThread;
    115114using WTF::waitForThreadCompletion;
    116 using WTF::yield;
    117115
    118116#endif // Threading_h

  • trunk/JavaScriptCore/wtf/ThreadingPthreads.cpp

    r64313 r64334  
    4545#if !COMPILER(MSVC)
    4646#include <limits.h>
    47 #include <sched.h>
    4847#include <sys/time.h>
    4948#endif
    … …  
    223222}
    224223
    225 void yield()
    226 {
    227     sched_yield();
    228 }
    229 
    230224ThreadIdentifier currentThread()
    231225{

  • trunk/JavaScriptCore/wtf/ThreadingWin.cpp

    r64313 r64334  
    265265        CloseHandle(threadHandle);
    266266    clearThreadHandleForIdentifier(threadID);
    267 }
    268 
    269 void yield()
    270 {
    271     ::Sleep(1);
    272267}
    273268

  • trunk/JavaScriptCore/wtf/gtk/ThreadingGtk.cpp

    r64313 r64334  
    168168}
    169169
    170 void yield()
    171 {
    172     g_thread_yield();
    173 }
    174 
    175170Mutex::Mutex()
    176171    : m_mutex(g_mutex_new())

  • trunk/JavaScriptCore/wtf/qt/ThreadingQt.cpp

    r64313 r64334  
    209209}
    210210
    211 void yield()
    212 {
    213     QThread::yieldCurrentThread();
    214 }
    215 
    216211Mutex::Mutex()
    217212    : m_mutex(new QMutex())

  • trunk/LayoutTests/ChangeLog

    r64329 r64334  
     12010-07-29  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r64313.
     4        http://trac.webkit.org/changeset/64313
     5        https://bugs.webkit.org/show_bug.cgi?id=43233
     6
     7        Some Chromium bots are not happy with it for some unknown
     8        reason. (Requested by dumi on #webkit).
     9
     10        * fast/workers/storage/interrupt-database-expected.txt: Removed.
     11        * fast/workers/storage/interrupt-database-sync-expected.txt: Removed.
     12        * fast/workers/storage/interrupt-database-sync.html: Removed.
     13        * fast/workers/storage/interrupt-database.html: Removed.
     14        * fast/workers/storage/resources/interrupt-database-sync.js: Removed.
     15        * fast/workers/storage/resources/interrupt-database.js: Removed.
     16
    1172010-07-29  Victor Wang  <victorw@chromium.org>
    218

  • trunk/WebCore/ChangeLog

    r64322 r64334  
     12010-07-29  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r64313.
     4        http://trac.webkit.org/changeset/64313
     5        https://bugs.webkit.org/show_bug.cgi?id=43233
     6
     7        Some Chromium bots are not happy with it for some unknown
     8        reason. (Requested by dumi on #webkit).
     9
     10        * bindings/js/JSCustomVoidCallback.cpp:
     11        (WebCore::JSCustomVoidCallback::~JSCustomVoidCallback):
     12        * bindings/scripts/CodeGeneratorJS.pm:
     13        * bindings/scripts/test/JS/JSTestCallback.cpp:
     14        (WebCore::JSTestCallback::~JSTestCallback):
     15        * platform/sql/SQLiteDatabase.cpp:
     16        (WebCore::SQLiteDatabase::SQLiteDatabase):
     17        (WebCore::SQLiteDatabase::close):
     18        (WebCore::SQLiteDatabase::lock):
     19        (WebCore::SQLiteDatabase::unlock):
     20        * platform/sql/SQLiteDatabase.h:
     21        * platform/sql/SQLiteStatement.cpp:
     22        (WebCore::SQLiteStatement::prepare):
     23        (WebCore::SQLiteStatement::step):
     24        * storage/AbstractDatabase.cpp:
     25        * storage/AbstractDatabase.h:
     26        * storage/DatabaseTracker.cpp:
     27        * storage/DatabaseTracker.h:
     28        * storage/SQLStatement.cpp:
     29        (WebCore::SQLStatement::execute):
     30        * storage/SQLStatementSync.cpp:
     31        (WebCore::SQLStatementSync::execute):
     32        * storage/SQLTransaction.cpp:
     33        (WebCore::SQLTransaction::checkAndHandleClosedDatabase):
     34        (WebCore::SQLTransaction::performNextStep):
     35        (WebCore::SQLTransaction::performPendingCallback):
     36        (WebCore::SQLTransaction::deliverTransactionCallback):
     37        (WebCore::SQLTransaction::postflightAndCommit):
     38        (WebCore::SQLTransaction::deliverTransactionErrorCallback):
     39        (WebCore::SQLTransaction::cleanupAfterTransactionErrorCallback):
     40        * storage/SQLTransaction.h:
     41        * storage/chromium/DatabaseTrackerChromium.cpp:
     42        * workers/WorkerThread.cpp:
     43        (WebCore::WorkerThread::stop):
     44
    1452010-07-29  Martin Robinson  <mrobinson@igalia.com>
    246

  • trunk/WebCore/bindings/js/JSCustomVoidCallback.cpp

    r64313 r64334  
    4949JSCustomVoidCallback::~JSCustomVoidCallback()
    5050{
    51     if (m_scriptExecutionContext->isContextThread())
    52         delete m_data;
    53     else
    54         m_scriptExecutionContext->postTask(DeleteCallbackDataTask::create(m_data));
     51    m_scriptExecutionContext->postTask(DeleteCallbackDataTask::create(m_data));
    5552#ifndef NDEBUG
    5653    m_data = 0;

  • trunk/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r64313 r64334  
    21522152    push(@implContent, "${className}::~${className}()\n");
    21532153    push(@implContent, "{\n");
    2154     push(@implContent, "    if (m_scriptExecutionContext->isContextThread())\n");
    2155     push(@implContent, "        delete m_data;\n");
    2156     push(@implContent, "    else\n");
    2157     push(@implContent, "        m_scriptExecutionContext->postTask(DeleteCallbackDataTask::create(m_data));\n");
     2154    push(@implContent, "    m_scriptExecutionContext->postTask(DeleteCallbackDataTask::create(m_data));\n");
    21582155    push(@implContent, "#ifndef NDEBUG\n");
    21592156    push(@implContent, "    m_data = 0;\n");

  • trunk/WebCore/bindings/scripts/test/JS/JSTestCallback.cpp

    r64313 r64334  
    4444JSTestCallback::~JSTestCallback()
    4545{
    46     if (m_scriptExecutionContext->isContextThread())
    47         delete m_data;
    48     else
    49         m_scriptExecutionContext->postTask(DeleteCallbackDataTask::create(m_data));
     46    m_scriptExecutionContext->postTask(DeleteCallbackDataTask::create(m_data));
    5047#ifndef NDEBUG
    5148    m_data = 0;

  • trunk/WebCore/platform/sql/SQLiteDatabase.cpp

    r64313 r64334  
    3232#include "SQLiteFileSystem.h"
    3333#include "SQLiteStatement.h"
     34
    3435#include <sqlite3.h>
    35 #include <wtf/Threading.h>
    3636
    3737namespace WebCore {
    … …  
    4343const int SQLResultSchema = SQLITE_SCHEMA;
    4444const int SQLResultFull = SQLITE_FULL;
    45 const int SQLResultInterrupt = SQLITE_INTERRUPT;
     45
    4646
    4747SQLiteDatabase::SQLiteDatabase()
    … …  
    5151    , m_sharable(false)
    5252    , m_openingThread(0)
    53     , m_interrupted(false)
    5453{
    5554}
    … …  
    8584{
    8685    if (m_db) {
    87         ASSERT(currentThread() == m_openingThread);
    88         sqlite3* db = m_db;
    89         {
    90             MutexLocker locker(m_databaseClosingMutex);
    91             m_db = 0;
    92         }
    93         sqlite3_close(db);
     86        // FIXME: This is being called on themain thread during JS GC. <rdar://problem/5739818>
     87        // ASSERT(currentThread() == m_openingThread);
     88        sqlite3_close(m_db);
     89        m_db = 0;
    9490    }
    9591
    9692    m_openingThread = 0;
    97 }
    98 
    99 void SQLiteDatabase::interrupt()
    100 {
    101     m_interrupted = true;
    102     while (!m_lockingMutex.tryLock()) {
    103         MutexLocker locker(m_databaseClosingMutex);
    104         if (!m_db)
    105             return;
    106         sqlite3_interrupt(m_db);
    107         yield();
    108     }
    109 
    110     m_lockingMutex.unlock();
    111 }
    112 
    113 bool SQLiteDatabase::isInterrupted()
    114 {
    115     ASSERT(!m_lockingMutex.tryLock());
    116     return m_interrupted;
    11793}
    11894
    … …  
    422398}
    423399
     400void SQLiteDatabase::lock()
     401{
     402    m_lockingMutex.lock();
     403}
     404
     405void SQLiteDatabase::unlock()
     406{
     407    m_lockingMutex.unlock();
     408}
     409
    424410bool SQLiteDatabase::isAutoCommitOn() const
    425411{

  • trunk/WebCore/platform/sql/SQLiteDatabase.h

    r64313 r64334  
    4949extern const int SQLResultSchema;
    5050extern const int SQLResultFull;
    51 extern const int SQLResultInterrupt;
    5251
    5352class SQLiteDatabase : public Noncopyable {
    … …  
    6059    bool isOpen() const { return m_db; }
    6160    void close();
    62     void interrupt();
    63     bool isInterrupted();
    6461
    6562    bool executeCommand(const String&);
    … …  
    109106    void setAuthorizer(PassRefPtr<DatabaseAuthorizer>);
    110107
    111     Mutex& databaseMutex() { return m_lockingMutex; }
     108    // (un)locks the database like a mutex
     109    void lock();
     110    void unlock();
    112111    bool isAutoCommitOn() const;
    113112
    … …  
    151150    Mutex m_lockingMutex;
    152151    ThreadIdentifier m_openingThread;
    153 
    154     Mutex m_databaseClosingMutex;
    155     bool m_interrupted;
     152   
    156153}; // class SQLiteDatabase
    157154

  • trunk/WebCore/platform/sql/SQLiteStatement.cpp

    r64313 r64334  
    6262{
    6363    ASSERT(!m_isPrepared);
    64 
    65     MutexLocker databaseLock(m_database.databaseMutex());
    66     if (m_database.isInterrupted())
    67         return SQLITE_INTERRUPT;
    68 
    6964    const void* tail = 0;
    7065    LOG(SQLDatabase, "SQL - prepare - %s", m_query.ascii().data());
    … …  
    9489{
    9590    ASSERT(m_isPrepared);
    96 
    97     MutexLocker databaseLock(m_database.databaseMutex());
    98     if (m_database.isInterrupted())
    99         return SQLITE_INTERRUPT;
    100 
    10191    if (!m_statement)
    10292        return SQLITE_OK;

  • trunk/WebCore/storage/AbstractDatabase.cpp

    r64313 r64334  
    475475}
    476476
    477 void AbstractDatabase::interrupt()
    478 {
    479     m_sqliteDatabase.interrupt();
    480 }
    481 
    482 bool AbstractDatabase::isInterrupted()
    483 {
    484     MutexLocker locker(m_sqliteDatabase.databaseMutex());
    485     return m_sqliteDatabase.isInterrupted();
    486 }
    487 
    488477} // namespace WebCore
    489478

  • trunk/WebCore/storage/AbstractDatabase.h

    r64313 r64334  
    6969    unsigned long long maximumSize() const;
    7070    void incrementalVacuumIfNeeded();
    71     void interrupt();
    72     bool isInterrupted();
    7371
    7472    // FIXME: move all version-related methods to a DatabaseVersionTracker class

  • trunk/WebCore/storage/DatabaseTracker.cpp

    r64313 r64334  
    236236}
    237237
    238 void DatabaseTracker::interruptAllDatabasesForContext(const ScriptExecutionContext* context)
    239 {
    240     Vector<RefPtr<AbstractDatabase> > openDatabases;
    241     {
    242         MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
    243 
    244         if (!m_openDatabaseMap)
    245             return;
    246 
    247         DatabaseNameMap* nameMap = m_openDatabaseMap->get(context->securityOrigin());
    248         if (!nameMap)
    249             return;
    250 
    251         DatabaseNameMap::const_iterator dbNameMapEndIt = nameMap->end();
    252         for (DatabaseNameMap::const_iterator dbNameMapIt = nameMap->begin(); dbNameMapIt != dbNameMapEndIt; ++dbNameMapIt) {
    253             DatabaseSet* databaseSet = dbNameMapIt->second;
    254             DatabaseSet::const_iterator dbSetEndIt = databaseSet->end();
    255             for (DatabaseSet::const_iterator dbSetIt = databaseSet->begin(); dbSetIt != dbSetEndIt; ++dbSetIt) {
    256                 if ((*dbSetIt)->scriptExecutionContext() == context)
    257                     openDatabases.append(*dbSetIt);
    258             }
    259         }
    260     }
    261 
    262     Vector<RefPtr<AbstractDatabase> >::const_iterator openDatabasesEndIt = openDatabases.end();
    263     for (Vector<RefPtr<AbstractDatabase> >::const_iterator openDatabasesIt = openDatabases.begin(); openDatabasesIt != openDatabasesEndIt; ++openDatabasesIt)
    264         (*openDatabasesIt)->interrupt();
    265 }
    266 
    267238String DatabaseTracker::originPath(SecurityOrigin* origin) const
    268239{

  • trunk/WebCore/storage/DatabaseTracker.h

    r64313 r64334  
    7878    unsigned long long getMaxSizeForDatabase(const AbstractDatabase*);
    7979    void databaseChanged(AbstractDatabase*);
    80 
    81     void interruptAllDatabasesForContext(const ScriptExecutionContext*);
    8280
    8381private:

  • trunk/WebCore/storage/SQLStatement.cpp

    r64313 r64334  
    7979    if (result != SQLResultOk) {
    8080        LOG(StorageAPI, "Unable to verify correctness of statement %s - error %i (%s)", m_statement.ascii().data(), result, database->lastErrorMsg());
    81         m_error = SQLError::create(result == SQLResultInterrupt ? SQLError::DATABASE_ERR : SQLError::SYNTAX_ERR, database->lastErrorMsg());
     81        m_error = SQLError::create(SQLError::SYNTAX_ERR, database->lastErrorMsg());
    8282        return false;
    8383    }
    … …  
    8787    if (statement.bindParameterCount() != m_arguments.size()) {
    8888        LOG(StorageAPI, "Bind parameter count doesn't match number of question marks");
    89         m_error = SQLError::create(db->isInterrupted() ? SQLError::DATABASE_ERR : SQLError::SYNTAX_ERR, "number of '?'s in statement string does not match argument count");
     89        m_error = SQLError::create(SQLError::SYNTAX_ERR, "number of '?'s in statement string does not match argument count");
    9090        return false;
    9191    }

  • trunk/WebCore/storage/SQLStatementSync.cpp

    r64313 r64334  
    6262    int result = statement.prepare();
    6363    if (result != SQLResultOk) {
    64         ec = (result == SQLResultInterrupt ? SQLException::DATABASE_ERR : SQLException::SYNTAX_ERR);
     64        ec = SQLException::SYNTAX_ERR;
    6565        return 0;
    6666    }
    6767
    6868    if (statement.bindParameterCount() != m_arguments.size()) {
    69         ec = (db->isInterrupted()? SQLException::DATABASE_ERR : SQLException::SYNTAX_ERR);
     69        ec = SQLException::SYNTAX_ERR;
    7070        return 0;
    7171    }

  • trunk/WebCore/storage/SQLTransaction.cpp

    r64313 r64334  
    147147#endif
    148148
    149 void SQLTransaction::checkAndHandleClosedOrInterruptedDatabase()
    150 {
    151     if (m_database->opened() && !m_database->isInterrupted())
     149void SQLTransaction::checkAndHandleClosedDatabase()
     150{
     151    if (m_database->opened())
    152152        return;
    153153
    154154    // If the database was stopped, don't do anything and cancel queued work
    155     LOG(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
     155    LOG(StorageAPI, "Database was stopped - cancelling work for this transaction");
    156156    MutexLocker locker(m_statementMutex);
    157157    m_statementQueue.clear();
    158158    m_nextStep = 0;
    159 
    160     // Release the unneeded callbacks, to break reference cycles.
    161     m_callback = 0;
    162     m_successCallback = 0;
    163     m_errorCallback = 0;
    164159
    165160    // The next steps should be executed only if we're on the DB thread.
    … …  
    189184           m_nextStep == &SQLTransaction::cleanupAfterTransactionErrorCallback);
    190185
    191     checkAndHandleClosedOrInterruptedDatabase();
     186    checkAndHandleClosedDatabase();
    192187
    193188    if (m_nextStep)
    … …  
    208203           m_nextStep == &SQLTransaction::deliverSuccessCallback);
    209204
    210     checkAndHandleClosedOrInterruptedDatabase();
     205    checkAndHandleClosedDatabase();
    211206
    212207    if (m_nextStep)
    … …  
    298293        shouldDeliverErrorCallback = !m_callback->handleEvent(m_database->scriptExecutionContext(), this);
    299294        m_executeSqlAllowed = false;
    300         m_callback = 0;
    301295    }
    302296
    … …  
    466460    // If the commit failed, the transaction will still be marked as "in progress"
    467461    if (m_sqliteTransaction->inProgress()) {
    468         m_successCallback = 0;
    469462        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "failed to commit the transaction");
    470463        handleTransactionError(false);
    … …  
    481474
    482475    // Now release our unneeded callbacks, to break reference cycles.
     476    m_callback = 0;
    483477    m_errorCallback = 0;
    484478
    … …  
    553547    // Transaction Step 12 - If exists, invoke error callback with the last
    554548    // error to have occurred in this transaction.
    555     if (m_errorCallback) {
     549    if (m_errorCallback)
    556550        m_errorCallback->handleEvent(m_database->scriptExecutionContext(), m_transactionError.get());
    557         m_errorCallback = 0;
    558     }
    559551
    560552    m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
    … …  
    588580    m_nextStep = 0;
    589581
     582    // Now release our callbacks, to break reference cycles.
     583    m_callback = 0;
     584    m_errorCallback = 0;
     585
    590586    // Now release the lock on this database
    591587    m_database->transactionCoordinator()->releaseLock(this);

  • trunk/WebCore/storage/SQLTransaction.h

    r64313 r64334  
    8888    void enqueueStatement(PassRefPtr<SQLStatement>);
    8989
    90     void checkAndHandleClosedOrInterruptedDatabase();
     90    void checkAndHandleClosedDatabase();
    9191
    9292    void acquireLock();

  • trunk/WebCore/storage/chromium/DatabaseTrackerChromium.cpp

    r64313 r64334  
    175175}
    176176
    177 void DatabaseTracker::interruptAllDatabasesForContext(const ScriptExecutionContext* context)
    178 {
    179     Vector<RefPtr<AbstractDatabase> > openDatabases;
    180     {
    181         MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
    182 
    183         if (!m_openDatabaseMap)
    184             return;
    185 
    186         DatabaseNameMap* nameMap = m_openDatabaseMap->get(context->securityOrigin());
    187         if (!nameMap)
    188             return;
    189 
    190         DatabaseNameMap::const_iterator dbNameMapEndIt = nameMap->end();
    191         for (DatabaseNameMap::const_iterator dbNameMapIt = nameMap->begin(); dbNameMapIt != dbNameMapEndIt; ++dbNameMapIt) {
    192             DatabaseSet* databaseSet = dbNameMapIt->second;
    193             DatabaseSet::const_iterator dbSetEndIt = databaseSet->end();
    194             for (DatabaseSet::const_iterator dbSetIt = databaseSet->begin(); dbSetIt != dbSetEndIt; ++dbSetIt) {
    195                 if ((*dbSetIt)->scriptExecutionContext() == context)
    196                     openDatabases.append(*dbSetIt);
    197             }
    198         }
    199     }
    200 
    201     Vector<RefPtr<AbstractDatabase> >::const_iterator openDatabasesEndIt = openDatabases.end();
    202     for (Vector<RefPtr<AbstractDatabase> >::const_iterator openDatabasesIt = openDatabases.begin(); openDatabasesIt != openDatabasesEndIt; ++openDatabasesIt)
    203         (*openDatabasesIt)->interrupt();
    204 }
    205 
    206177}
    207178

  • trunk/WebCore/workers/WorkerThread.cpp

    r64313 r64334  
    3131#include "WorkerThread.h"
    3232
     33#include "DatabaseTask.h"
    3334#include "DedicatedWorkerContext.h"
    3435#include "KURL.h"
    … …  
    4142#include <wtf/Noncopyable.h>
    4243
    43 #if ENABLE(DATABASE)
    44 #include "DatabaseTask.h"
    45 #include "DatabaseTracker.h"
    46 #endif
    47 
    4844namespace WebCore {
    4945
    … …  
    230226        m_workerContext->script()->forbidExecution(WorkerScriptController::TerminateRunningScript);
    231227
    232 #if ENABLE(DATABASE)
    233         DatabaseTracker::tracker().interruptAllDatabasesForContext(m_workerContext.get());
    234 #endif
    235 
    236228    // FIXME: Rudely killing the thread won't work when we allow nested workers, because they will try to post notifications of their destruction.
    237229    // This can likely use the same mechanism as used for databases above.
Note: See TracChangeset for help on using the changeset viewer.