TEST(WTF_Deque, Remove)
{
Deque<int> deque;
deque.append(11);
deque.prepend(10);
deque.append(12);
deque.append(13);
EXPECT_EQ(10, deque.first());
EXPECT_EQ(13, deque.last());
deque.removeLast();
EXPECT_EQ(10, deque.first());
EXPECT_EQ(12, deque.last());
deque.removeFirst();
EXPECT_EQ(11, deque.first());
EXPECT_EQ(12, deque.last());
deque.removeFirst();
EXPECT_EQ(12, deque.first());
EXPECT_EQ(12, deque.last());
deque.removeLast();
EXPECT_TRUE(deque.isEmpty());
}
void main ( void )
{
Deque<int> intQ;
printf ( "isEmpty(1): %d\n", intQ.isEmpty ( ) ? 1 : 0 );
intQ.insertFirst ( 4 );
cout << intQ <<endl;
printf ( "removeLast(4): %d\n", intQ.removeLast ( ) );
cout << intQ <<endl;
intQ.insertFirst ( 5 );
intQ.insertFirst ( 12 );
intQ.insertLast ( 7 );
intQ.insertLast ( 13 );
cout << intQ <<endl;
printf ( "first(12): %d\n", intQ.first ( ) );
printf ( "last(13): %d\n", intQ.last ( ) );
printf ( "size(4): %d\n", intQ.size ( ) );
printf ( "isEmpty(0): %d\n", intQ.isEmpty ( ) ? 1 : 0 );
printf ( "removeLast(13) :%d\n", intQ.removeLast ( ) );
printf ( "removeLast(7) :%d\n", intQ.removeLast ( ) );
printf ( "removeLast(5) :%d\n", intQ.removeLast ( ) );
cout << intQ <<endl;
printf ( "removeFirst(12) :%d\n", intQ.removeFirst ( ) );
cout << intQ <<endl;
printf ( "size(0): %d\n", intQ.size ( ) );
printf ( "isEmpty(1): %d\n", intQ.isEmpty ( ) ? 1 : 0 );
intQ.removeLast ( );
}
RefPtr<UniqueIDBDatabaseTransaction> UniqueIDBDatabase::takeNextRunnableTransaction(bool& hadDeferredTransactions)
{
Deque<RefPtr<UniqueIDBDatabaseTransaction>> deferredTransactions;
RefPtr<UniqueIDBDatabaseTransaction> currentTransaction;
while (!m_pendingTransactions.isEmpty()) {
currentTransaction = m_pendingTransactions.takeFirst();
switch (currentTransaction->info().mode()) {
case IndexedDB::TransactionMode::ReadOnly:
// If there are any deferred transactions, the first one is a read-write transaction we need to unblock.
// Therefore, skip this read-only transaction if its scope overlaps with that read-write transaction.
if (!deferredTransactions.isEmpty()) {
ASSERT(deferredTransactions.first()->info().mode() == IndexedDB::TransactionMode::ReadWrite);
if (scopesOverlap(deferredTransactions.first()->objectStoreIdentifiers(), currentTransaction->objectStoreIdentifiers()))
deferredTransactions.append(WTF::move(currentTransaction));
}
break;
case IndexedDB::TransactionMode::ReadWrite:
// If this read-write transaction's scope overlaps with running transactions, it must be deferred.
if (scopesOverlap(m_objectStoreTransactionCounts, currentTransaction->objectStoreIdentifiers()))
deferredTransactions.append(WTF::move(currentTransaction));
break;
case IndexedDB::TransactionMode::VersionChange:
// Version change transactions should never be scheduled in the traditional manner.
RELEASE_ASSERT_NOT_REACHED();
}
// If we didn't defer the currentTransaction above, it can be run now.
if (currentTransaction)
break;
}
hadDeferredTransactions = !deferredTransactions.isEmpty();
if (!hadDeferredTransactions)
return WTF::move(currentTransaction);
// Prepend the deferred transactions back on the beginning of the deque for future scheduling passes.
while (!deferredTransactions.isEmpty())
m_pendingTransactions.prepend(deferredTransactions.takeLast());
return WTF::move(currentTransaction);
}
TEST(WTF_Deque, MoveOnly)
{
Deque<MoveOnly> deque;
deque.append(MoveOnly(1));
deque.prepend(MoveOnly(0));
EXPECT_EQ(0U, deque.first().value());
EXPECT_EQ(1U, deque.last().value());
auto first = deque.takeFirst();
EXPECT_EQ(0U, first.value());
auto last = deque.takeLast();
EXPECT_EQ(1U, last.value());
}
void DatabaseThread::unscheduleDatabaseTasks(Database* database)
{
// Note that the thread loop is running, so some tasks for the database
// may still be executed. This is unavoidable.
Deque<RefPtr<DatabaseTask> > filteredReverseQueue;
RefPtr<DatabaseTask> task;
while (m_queue.tryGetMessage(task)) {
if (task->database() != database)
filteredReverseQueue.append(task);
}
while (!filteredReverseQueue.isEmpty()) {
m_queue.append(filteredReverseQueue.first());
filteredReverseQueue.removeFirst();
}
}
void CSSStyleSheet::addSubresourceStyleURLs(ListHashSet<KURL>& urls)
{
Deque<CSSStyleSheet*> styleSheetQueue;
styleSheetQueue.append(this);
while (!styleSheetQueue.isEmpty()) {
CSSStyleSheet* styleSheet = styleSheetQueue.first();
styleSheetQueue.removeFirst();
RefPtr<CSSRuleList> ruleList = styleSheet->cssRules();
for (unsigned i = 0; i < ruleList->length(); ++i) {
CSSRule* rule = ruleList->item(i);
if (rule->isImportRule()) {
if (CSSStyleSheet* ruleStyleSheet = static_cast<CSSImportRule*>(rule)->styleSheet())
styleSheetQueue.append(ruleStyleSheet);
}
rule->addSubresourceStyleURLs(urls);
}
}
}
