[SCM] WebKit Debian packaging branch, webkit-1.2, updated. upstream/1.1.90-6072-g9a69373
dimich at chromium.org
dimich at chromium.org
Wed Apr 7 23:18:40 UTC 2010
The following commit has been merged in the webkit-1.2 branch:
commit 142155ae330554909fe70a813e8828bc5b782887
Author: dimich at chromium.org <dimich at chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Mon Nov 2 21:31:22 2009 +0000
Remove threadsafe refcounting from tasks used with WTF::MessageQueue.
https://bugs.webkit.org/show_bug.cgi?id=30612
Reviewed by David Levin.
JavaScriptCore:
* wtf/MessageQueue.h:
(WTF::MessageQueue::alwaysTruePredicate):
(WTF::MessageQueue::~MessageQueue):
(WTF::MessageQueue::append):
(WTF::MessageQueue::appendAndCheckEmpty):
(WTF::MessageQueue::prepend):
(WTF::MessageQueue::waitForMessage):
(WTF::MessageQueue::waitForMessageFilteredWithTimeout):
(WTF::MessageQueue::tryGetMessage):
(WTF::MessageQueue::removeIf):
The MessageQueue is changed to act as a queue of OwnPtr<DataType>. It takes ownership
of posted tasks and passes it to the new owner (in another thread) when the task is fetched.
All methods have arguments of type PassOwnPtr<DataType> and return the same type.
* wtf/Threading.cpp:
(WTF::createThread):
Superficial change to trigger rebuild of JSC project on Windows,
workaround for https://bugs.webkit.org/show_bug.cgi?id=30890
WebCore:
No new tests since no new functionality. Storage, MessagePorts and Workers tests cover this.
There are a lot of files but most changes are simply replace RefPtr and PassRefPtr with
OwnPtr and PassOwnPtr when dealing with Tasks.
ScriptExecutionContext::Task, DatabaseTask and WorkerRunLoop::Task are no longer
threadsafe refcounted, but simply Noncopyable.
* dom/Document.cpp:
(WebCore::ScriptExecutionContextTaskTimer::ScriptExecutionContextTaskTimer):
(WebCore::PerformTaskContext::PerformTaskContext):
(WebCore::Document::postTask):
* dom/Document.h:
* dom/ScriptExecutionContext.cpp:
(WebCore::ProcessMessagesSoonTask::create):
* dom/ScriptExecutionContext.h:
* dom/default/PlatformMessagePortChannel.cpp:
(WebCore::PlatformMessagePortChannel::tryGetMessageFromRemote):
* dom/default/PlatformMessagePortChannel.h:
(WebCore::PlatformMessagePortChannel::MessagePortQueue::tryGetMessage):
(WebCore::PlatformMessagePortChannel::MessagePortQueue::appendAndCheckEmpty):
* loader/FrameLoader.cpp:
(WebCore::HashChangeEventTask::create):
* loader/appcache/ApplicationCacheGroup.cpp:
(WebCore::CallCacheListenerTask::create):
* storage/Database.cpp:
(WebCore::Database::openAndVerifyVersion):
(WebCore::Database::markAsDeletedAndClose):
(WebCore::Database::scheduleTransaction):
(WebCore::Database::scheduleTransactionStep):
(WebCore::Database::tableNames):
* storage/DatabaseTask.h:
(WebCore::DatabaseOpenTask::create):
(WebCore::DatabaseCloseTask::create):
(WebCore::DatabaseTransactionTask::create):
(WebCore::DatabaseTableNamesTask::create):
* storage/DatabaseThread.cpp:
(WebCore::DatabaseThread::databaseThread):
(WebCore::DatabaseThread::scheduleTask):
(WebCore::DatabaseThread::scheduleImmediateTask):
(WebCore::SameDatabasePredicate::operator()):
* storage/DatabaseThread.h:
* storage/LocalStorageTask.h:
(WebCore::LocalStorageTask::createImport):
(WebCore::LocalStorageTask::createSync):
(WebCore::LocalStorageTask::createTerminate):
* storage/LocalStorageThread.cpp:
(WebCore::LocalStorageThread::localStorageThread):
* storage/LocalStorageThread.h:
* websockets/WebSocket.cpp:
(WebCore::ProcessWebSocketEventTask::create):
* workers/DefaultSharedWorkerRepository.cpp:
(WebCore::SharedWorkerProxy::postTaskToLoader):
(WebCore::SharedWorkerProxy::postTaskForModeToWorkerContext):
(WebCore::SharedWorkerConnectTask::create):
* workers/GenericWorkerTask.h:
(WebCore::GenericWorkerTask1::create):
(WebCore::GenericWorkerTask2::create):
(WebCore::GenericWorkerTask3::create):
(WebCore::GenericWorkerTask4::create):
(WebCore::GenericWorkerTask5::create):
(WebCore::GenericWorkerTask6::create):
(WebCore::GenericWorkerTask7::create):
(WebCore::GenericWorkerTask8::create):
(WebCore::createCallbackTask):
* workers/WorkerContext.cpp:
(WebCore::WorkerContext::postTask):
* workers/WorkerContext.h:
* workers/WorkerLoaderProxy.h:
* workers/WorkerMessagingProxy.cpp:
(WebCore::MessageWorkerContextTask::create):
(WebCore::MessageWorkerTask::create):
(WebCore::WorkerExceptionTask::create):
(WebCore::WorkerContextDestroyedTask::create):
(WebCore::WorkerTerminateTask::create):
(WebCore::WorkerThreadActivityReportTask::create):
(WebCore::WorkerMessagingProxy::postTaskForModeToWorkerContext):
(WebCore::WorkerMessagingProxy::postTaskToLoader):
(WebCore::WorkerMessagingProxy::workerThreadCreated):
* workers/WorkerMessagingProxy.h:
* workers/WorkerRunLoop.cpp:
(WebCore::ModePredicate::operator()):
(WebCore::WorkerRunLoop::runInMode):
(WebCore::WorkerRunLoop::postTask):
(WebCore::WorkerRunLoop::postTaskForMode):
(WebCore::WorkerRunLoop::Task::create):
(WebCore::WorkerRunLoop::Task::performTask):
(WebCore::WorkerRunLoop::Task::Task):
* workers/WorkerRunLoop.h:
(WebCore::WorkerRunLoop::Task::~Task):
(WebCore::WorkerRunLoop::Task::mode):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@50427 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/JavaScriptCore/ChangeLog b/JavaScriptCore/ChangeLog
index fd73cf9..6ae3865 100644
--- a/JavaScriptCore/ChangeLog
+++ b/JavaScriptCore/ChangeLog
@@ -1,3 +1,29 @@
+2009-11-02 Dmitry Titov <dimich at chromium.org>
+
+ Reviewed by David Levin.
+
+ Remove threadsafe refcounting from tasks used with WTF::MessageQueue.
+ https://bugs.webkit.org/show_bug.cgi?id=30612
+
+ * wtf/MessageQueue.h:
+ (WTF::MessageQueue::alwaysTruePredicate):
+ (WTF::MessageQueue::~MessageQueue):
+ (WTF::MessageQueue::append):
+ (WTF::MessageQueue::appendAndCheckEmpty):
+ (WTF::MessageQueue::prepend):
+ (WTF::MessageQueue::waitForMessage):
+ (WTF::MessageQueue::waitForMessageFilteredWithTimeout):
+ (WTF::MessageQueue::tryGetMessage):
+ (WTF::MessageQueue::removeIf):
+ The MessageQueue is changed to act as a queue of OwnPtr<DataType>. It takes ownership
+ of posted tasks and passes it to the new owner (in another thread) when the task is fetched.
+ All methods have arguments of type PassOwnPtr<DataType> and return the same type.
+
+ * wtf/Threading.cpp:
+ (WTF::createThread):
+ Superficial change to trigger rebuild of JSC project on Windows,
+ workaround for https://bugs.webkit.org/show_bug.cgi?id=30890
+
2009-10-30 Geoffrey Garen <ggaren at apple.com>
Reviewed by Oliver Hunt.
diff --git a/JavaScriptCore/wtf/MessageQueue.h b/JavaScriptCore/wtf/MessageQueue.h
index 9c9a4a7..bab848c 100644
--- a/JavaScriptCore/wtf/MessageQueue.h
+++ b/JavaScriptCore/wtf/MessageQueue.h
@@ -44,23 +44,27 @@ namespace WTF {
MessageQueueMessageReceived, // A message was successfully received and returned.
};
+ // The queue takes ownership of messages and transfer it to the new owner
+ // when messages are fetched from the queue.
+ // Essentially, MessageQueue acts as a queue of OwnPtr<DataType>.
template<typename DataType>
class MessageQueue : public Noncopyable {
public:
MessageQueue() : m_killed(false) { }
-
- void append(const DataType&);
- bool appendAndCheckEmpty(const DataType&);
- void prepend(const DataType&);
- bool waitForMessage(DataType&);
+ ~MessageQueue();
+
+ void append(PassOwnPtr<DataType>);
+ bool appendAndCheckEmpty(PassOwnPtr<DataType>);
+ void prepend(PassOwnPtr<DataType>);
+
+ PassOwnPtr<DataType> waitForMessage();
+ PassOwnPtr<DataType> tryGetMessage();
template<typename Predicate>
- MessageQueueWaitResult waitForMessageFilteredWithTimeout(DataType&, Predicate&, double absoluteTime);
+ PassOwnPtr<DataType> waitForMessageFilteredWithTimeout(MessageQueueWaitResult&, Predicate&, double absoluteTime);
template<typename Predicate>
void removeIf(Predicate&);
- bool tryGetMessage(DataType&);
-
void kill();
bool killed() const;
@@ -70,86 +74,98 @@ namespace WTF {
static double infiniteTime() { return std::numeric_limits<double>::max(); }
private:
- static bool alwaysTruePredicate(DataType&) { return true; }
+ static bool alwaysTruePredicate(DataType*) { return true; }
mutable Mutex m_mutex;
ThreadCondition m_condition;
- Deque<DataType> m_queue;
+ Deque<DataType*> m_queue;
bool m_killed;
};
template<typename DataType>
- inline void MessageQueue<DataType>::append(const DataType& message)
+ MessageQueue<DataType>::~MessageQueue()
+ {
+ deleteAllValues(m_queue);
+ }
+
+ template<typename DataType>
+ inline void MessageQueue<DataType>::append(PassOwnPtr<DataType> message)
{
MutexLocker lock(m_mutex);
- m_queue.append(message);
+ m_queue.append(message.release());
m_condition.signal();
}
// Returns true if the queue was empty before the item was added.
template<typename DataType>
- inline bool MessageQueue<DataType>::appendAndCheckEmpty(const DataType& message)
+ inline bool MessageQueue<DataType>::appendAndCheckEmpty(PassOwnPtr<DataType> message)
{
MutexLocker lock(m_mutex);
bool wasEmpty = m_queue.isEmpty();
- m_queue.append(message);
+ m_queue.append(message.release());
m_condition.signal();
return wasEmpty;
}
template<typename DataType>
- inline void MessageQueue<DataType>::prepend(const DataType& message)
+ inline void MessageQueue<DataType>::prepend(PassOwnPtr<DataType> message)
{
MutexLocker lock(m_mutex);
- m_queue.prepend(message);
+ m_queue.prepend(message.release());
m_condition.signal();
}
template<typename DataType>
- inline bool MessageQueue<DataType>::waitForMessage(DataType& result)
+ inline PassOwnPtr<DataType> MessageQueue<DataType>::waitForMessage()
{
- MessageQueueWaitResult exitReason = waitForMessageFilteredWithTimeout(result, MessageQueue<DataType>::alwaysTruePredicate, infiniteTime());
+ MessageQueueWaitResult exitReason;
+ PassOwnPtr<DataType> result = waitForMessageFilteredWithTimeout(exitReason, MessageQueue<DataType>::alwaysTruePredicate, infiniteTime());
ASSERT(exitReason == MessageQueueTerminated || exitReason == MessageQueueMessageReceived);
- return exitReason == MessageQueueMessageReceived;
+ return result;
}
template<typename DataType>
template<typename Predicate>
- inline MessageQueueWaitResult MessageQueue<DataType>::waitForMessageFilteredWithTimeout(DataType& result, Predicate& predicate, double absoluteTime)
+ inline PassOwnPtr<DataType> MessageQueue<DataType>::waitForMessageFilteredWithTimeout(MessageQueueWaitResult& result, Predicate& predicate, double absoluteTime)
{
MutexLocker lock(m_mutex);
bool timedOut = false;
- DequeConstIterator<DataType> found = m_queue.end();
+ DequeConstIterator<DataType*> found = m_queue.end();
while (!m_killed && !timedOut && (found = m_queue.findIf(predicate)) == m_queue.end())
timedOut = !m_condition.timedWait(m_mutex, absoluteTime);
ASSERT(!timedOut || absoluteTime != infiniteTime());
- if (m_killed)
- return MessageQueueTerminated;
+ if (m_killed) {
+ result = MessageQueueTerminated;
+ return 0;
+ }
- if (timedOut)
- return MessageQueueTimeout;
+ if (timedOut) {
+ result = MessageQueueTimeout;
+ return 0;
+ }
ASSERT(found != m_queue.end());
- result = *found;
+ DataType* message = *found;
m_queue.remove(found);
- return MessageQueueMessageReceived;
+ result = MessageQueueMessageReceived;
+ return message;
}
template<typename DataType>
- inline bool MessageQueue<DataType>::tryGetMessage(DataType& result)
+ inline PassOwnPtr<DataType> MessageQueue<DataType>::tryGetMessage()
{
MutexLocker lock(m_mutex);
if (m_killed)
- return false;
+ return 0;
if (m_queue.isEmpty())
- return false;
+ return 0;
- result = m_queue.first();
+ DataType* message = m_queue.first();
m_queue.removeFirst();
- return true;
+ return message;
}
template<typename DataType>
@@ -157,9 +173,11 @@ namespace WTF {
inline void MessageQueue<DataType>::removeIf(Predicate& predicate)
{
MutexLocker lock(m_mutex);
- DequeConstIterator<DataType> found = m_queue.end();
+ DequeConstIterator<DataType*> found = m_queue.end();
while ((found = m_queue.findIf(predicate)) != m_queue.end()) {
+ DataType* message = *found;
m_queue.remove(found);
+ delete message;
}
}
diff --git a/JavaScriptCore/wtf/Threading.cpp b/JavaScriptCore/wtf/Threading.cpp
index 1d4185c..74c47f4 100644
--- a/JavaScriptCore/wtf/Threading.cpp
+++ b/JavaScriptCore/wtf/Threading.cpp
@@ -75,7 +75,7 @@ ThreadIdentifier createThread(ThreadFunction entryPoint, void* data, const char*
NewThreadContext* context = new NewThreadContext(entryPoint, data, name);
- // Prevent the thread body from executing until we've established the thread identifier
+ // Prevent the thread body from executing until we've established the thread identifier.
MutexLocker locker(context->creationMutex);
return createThreadInternal(threadEntryPoint, context, name);
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index 7925313..3c2bace 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,102 @@
+2009-11-02 Dmitry Titov <dimich at chromium.org>
+
+ Reviewed by David Levin.
+
+ Remove threadsafe refcounting from tasks used with WTF::MessageQueue.
+ https://bugs.webkit.org/show_bug.cgi?id=30612
+
+ No new tests since no new functionality. Storage, MessagePorts and Workers tests cover this.
+
+ There are a lot of files but most changes are simply replace RefPtr and PassRefPtr with
+ OwnPtr and PassOwnPtr when dealing with Tasks.
+
+ ScriptExecutionContext::Task, DatabaseTask and WorkerRunLoop::Task are no longer
+ threadsafe refcounted, but simply Noncopyable.
+
+ * dom/Document.cpp:
+ (WebCore::ScriptExecutionContextTaskTimer::ScriptExecutionContextTaskTimer):
+ (WebCore::PerformTaskContext::PerformTaskContext):
+ (WebCore::Document::postTask):
+ * dom/Document.h:
+ * dom/ScriptExecutionContext.cpp:
+ (WebCore::ProcessMessagesSoonTask::create):
+ * dom/ScriptExecutionContext.h:
+ * dom/default/PlatformMessagePortChannel.cpp:
+ (WebCore::PlatformMessagePortChannel::tryGetMessageFromRemote):
+ * dom/default/PlatformMessagePortChannel.h:
+ (WebCore::PlatformMessagePortChannel::MessagePortQueue::tryGetMessage):
+ (WebCore::PlatformMessagePortChannel::MessagePortQueue::appendAndCheckEmpty):
+ * loader/FrameLoader.cpp:
+ (WebCore::HashChangeEventTask::create):
+ * loader/appcache/ApplicationCacheGroup.cpp:
+ (WebCore::CallCacheListenerTask::create):
+ * storage/Database.cpp:
+ (WebCore::Database::openAndVerifyVersion):
+ (WebCore::Database::markAsDeletedAndClose):
+ (WebCore::Database::scheduleTransaction):
+ (WebCore::Database::scheduleTransactionStep):
+ (WebCore::Database::tableNames):
+ * storage/DatabaseTask.h:
+ (WebCore::DatabaseOpenTask::create):
+ (WebCore::DatabaseCloseTask::create):
+ (WebCore::DatabaseTransactionTask::create):
+ (WebCore::DatabaseTableNamesTask::create):
+ * storage/DatabaseThread.cpp:
+ (WebCore::DatabaseThread::databaseThread):
+ (WebCore::DatabaseThread::scheduleTask):
+ (WebCore::DatabaseThread::scheduleImmediateTask):
+ (WebCore::SameDatabasePredicate::operator()):
+ * storage/DatabaseThread.h:
+ * storage/LocalStorageTask.h:
+ (WebCore::LocalStorageTask::createImport):
+ (WebCore::LocalStorageTask::createSync):
+ (WebCore::LocalStorageTask::createTerminate):
+ * storage/LocalStorageThread.cpp:
+ (WebCore::LocalStorageThread::localStorageThread):
+ * storage/LocalStorageThread.h:
+ * websockets/WebSocket.cpp:
+ (WebCore::ProcessWebSocketEventTask::create):
+ * workers/DefaultSharedWorkerRepository.cpp:
+ (WebCore::SharedWorkerProxy::postTaskToLoader):
+ (WebCore::SharedWorkerProxy::postTaskForModeToWorkerContext):
+ (WebCore::SharedWorkerConnectTask::create):
+ * workers/GenericWorkerTask.h:
+ (WebCore::GenericWorkerTask1::create):
+ (WebCore::GenericWorkerTask2::create):
+ (WebCore::GenericWorkerTask3::create):
+ (WebCore::GenericWorkerTask4::create):
+ (WebCore::GenericWorkerTask5::create):
+ (WebCore::GenericWorkerTask6::create):
+ (WebCore::GenericWorkerTask7::create):
+ (WebCore::GenericWorkerTask8::create):
+ (WebCore::createCallbackTask):
+ * workers/WorkerContext.cpp:
+ (WebCore::WorkerContext::postTask):
+ * workers/WorkerContext.h:
+ * workers/WorkerLoaderProxy.h:
+ * workers/WorkerMessagingProxy.cpp:
+ (WebCore::MessageWorkerContextTask::create):
+ (WebCore::MessageWorkerTask::create):
+ (WebCore::WorkerExceptionTask::create):
+ (WebCore::WorkerContextDestroyedTask::create):
+ (WebCore::WorkerTerminateTask::create):
+ (WebCore::WorkerThreadActivityReportTask::create):
+ (WebCore::WorkerMessagingProxy::postTaskForModeToWorkerContext):
+ (WebCore::WorkerMessagingProxy::postTaskToLoader):
+ (WebCore::WorkerMessagingProxy::workerThreadCreated):
+ * workers/WorkerMessagingProxy.h:
+ * workers/WorkerRunLoop.cpp:
+ (WebCore::ModePredicate::operator()):
+ (WebCore::WorkerRunLoop::runInMode):
+ (WebCore::WorkerRunLoop::postTask):
+ (WebCore::WorkerRunLoop::postTaskForMode):
+ (WebCore::WorkerRunLoop::Task::create):
+ (WebCore::WorkerRunLoop::Task::performTask):
+ (WebCore::WorkerRunLoop::Task::Task):
+ * workers/WorkerRunLoop.h:
+ (WebCore::WorkerRunLoop::Task::~Task):
+ (WebCore::WorkerRunLoop::Task::mode):
+
2009-11-02 Philippe Normand <pnormand at igalia.com>
Reviewed by Jan Alonzo.
diff --git a/WebCore/dom/Document.cpp b/WebCore/dom/Document.cpp
index 70fb5c7..fba460d 100644
--- a/WebCore/dom/Document.cpp
+++ b/WebCore/dom/Document.cpp
@@ -4537,7 +4537,7 @@ void Document::scriptImported(unsigned long identifier, const String& sourceStri
class ScriptExecutionContextTaskTimer : public TimerBase {
public:
- ScriptExecutionContextTaskTimer(PassRefPtr<Document> context, PassRefPtr<ScriptExecutionContext::Task> task)
+ ScriptExecutionContextTaskTimer(PassRefPtr<Document> context, PassOwnPtr<ScriptExecutionContext::Task> task)
: m_context(context)
, m_task(task)
{
@@ -4551,18 +4551,18 @@ private:
}
RefPtr<Document> m_context;
- RefPtr<ScriptExecutionContext::Task> m_task;
+ OwnPtr<ScriptExecutionContext::Task> m_task;
};
struct PerformTaskContext {
- PerformTaskContext(ScriptExecutionContext* scriptExecutionContext, PassRefPtr<ScriptExecutionContext::Task> task)
+ PerformTaskContext(ScriptExecutionContext* scriptExecutionContext, PassOwnPtr<ScriptExecutionContext::Task> task)
: scriptExecutionContext(scriptExecutionContext)
, task(task)
{
}
ScriptExecutionContext* scriptExecutionContext; // The context should exist until task execution.
- RefPtr<ScriptExecutionContext::Task> task;
+ OwnPtr<ScriptExecutionContext::Task> task;
};
static void performTask(void* ctx)
@@ -4572,7 +4572,7 @@ static void performTask(void* ctx)
delete ptctx;
}
-void Document::postTask(PassRefPtr<Task> task)
+void Document::postTask(PassOwnPtr<Task> task)
{
if (isMainThread()) {
ScriptExecutionContextTaskTimer* timer = new ScriptExecutionContextTaskTimer(static_cast<Document*>(this), task);
diff --git a/WebCore/dom/Document.h b/WebCore/dom/Document.h
index 0632be1..2bfa8d9 100644
--- a/WebCore/dom/Document.h
+++ b/WebCore/dom/Document.h
@@ -819,7 +819,7 @@ public:
virtual void addMessage(MessageDestination, MessageSource, MessageType, MessageLevel, const String& message, unsigned lineNumber, const String& sourceURL);
virtual void resourceRetrievedByXMLHttpRequest(unsigned long identifier, const ScriptString& sourceString);
virtual void scriptImported(unsigned long, const String&);
- virtual void postTask(PassRefPtr<Task>); // Executes the task on context's thread asynchronously.
+ virtual void postTask(PassOwnPtr<Task>); // Executes the task on context's thread asynchronously.
typedef HashMap<WebCore::Node*, JSNode*> JSWrapperCache;
typedef HashMap<DOMWrapperWorld*, JSWrapperCache*> JSWrapperCacheMap;
diff --git a/WebCore/dom/ScriptExecutionContext.cpp b/WebCore/dom/ScriptExecutionContext.cpp
index f7046e3..bc71084 100644
--- a/WebCore/dom/ScriptExecutionContext.cpp
+++ b/WebCore/dom/ScriptExecutionContext.cpp
@@ -44,9 +44,9 @@ namespace WebCore {
class ProcessMessagesSoonTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<ProcessMessagesSoonTask> create()
+ static PassOwnPtr<ProcessMessagesSoonTask> create()
{
- return adoptRef(new ProcessMessagesSoonTask);
+ return new ProcessMessagesSoonTask;
}
virtual void performTask(ScriptExecutionContext* context)
diff --git a/WebCore/dom/ScriptExecutionContext.h b/WebCore/dom/ScriptExecutionContext.h
index 398afec..1414125 100644
--- a/WebCore/dom/ScriptExecutionContext.h
+++ b/WebCore/dom/ScriptExecutionContext.h
@@ -92,13 +92,13 @@ namespace WebCore {
void ref() { refScriptExecutionContext(); }
void deref() { derefScriptExecutionContext(); }
- class Task : public ThreadSafeShared<Task> {
+ class Task : public Noncopyable {
public:
virtual ~Task();
virtual void performTask(ScriptExecutionContext*) = 0;
};
- virtual void postTask(PassRefPtr<Task>) = 0; // Executes the task on context's thread asynchronously.
+ virtual void postTask(PassOwnPtr<Task>) = 0; // Executes the task on context's thread asynchronously.
void addTimeout(int timeoutId, DOMTimer*);
void removeTimeout(int timeoutId);
diff --git a/WebCore/dom/default/PlatformMessagePortChannel.cpp b/WebCore/dom/default/PlatformMessagePortChannel.cpp
index d668703..9e0e7dc 100644
--- a/WebCore/dom/default/PlatformMessagePortChannel.cpp
+++ b/WebCore/dom/default/PlatformMessagePortChannel.cpp
@@ -193,7 +193,8 @@ void PlatformMessagePortChannel::postMessageToRemote(PassOwnPtr<MessagePortChann
bool PlatformMessagePortChannel::tryGetMessageFromRemote(OwnPtr<MessagePortChannel::EventData>& result)
{
MutexLocker lock(m_mutex);
- return m_incomingQueue->tryGetMessage(result);
+ result = m_incomingQueue->tryGetMessage();
+ return result;
}
bool PlatformMessagePortChannel::isConnectedTo(MessagePort* port)
diff --git a/WebCore/dom/default/PlatformMessagePortChannel.h b/WebCore/dom/default/PlatformMessagePortChannel.h
index 0ce2d13..2aad952 100644
--- a/WebCore/dom/default/PlatformMessagePortChannel.h
+++ b/WebCore/dom/default/PlatformMessagePortChannel.h
@@ -63,18 +63,14 @@ namespace WebCore {
public:
static PassRefPtr<MessagePortQueue> create() { return adoptRef(new MessagePortQueue()); }
- bool tryGetMessage(OwnPtr<MessagePortChannel::EventData>& message)
+ PassOwnPtr<MessagePortChannel::EventData> tryGetMessage()
{
- MessagePortChannel::EventData* holder = 0;
- bool messageAvailable = m_queue.tryGetMessage(holder);
- if (messageAvailable)
- message.set(holder);
- return messageAvailable;
+ return m_queue.tryGetMessage();
}
bool appendAndCheckEmpty(PassOwnPtr<MessagePortChannel::EventData> message)
{
- return m_queue.appendAndCheckEmpty(message.release());
+ return m_queue.appendAndCheckEmpty(message);
}
bool isEmpty()
@@ -82,19 +78,10 @@ namespace WebCore {
return m_queue.isEmpty();
}
- ~MessagePortQueue()
- {
- // Manually free any items left in the queue, since we can't use OwnPtr internally.
- MessagePortChannel::EventData* data = 0;
- while (m_queue.tryGetMessage(data))
- delete data;
- }
private:
MessagePortQueue() { }
- // OwnPtr is Noncopyable, so we can't use it as the template type in a MessageQueue. So we just store a pointer to EventData and manually free it in the destructor.
- // FIXME: Use a lock-free queue implementation to completely eliminate contention when sending/receiving messages.
- MessageQueue<MessagePortChannel::EventData*> m_queue;
+ MessageQueue<MessagePortChannel::EventData> m_queue;
};
~PlatformMessagePortChannel();
diff --git a/WebCore/loader/FrameLoader.cpp b/WebCore/loader/FrameLoader.cpp
index 9b15448..9e52666 100644
--- a/WebCore/loader/FrameLoader.cpp
+++ b/WebCore/loader/FrameLoader.cpp
@@ -1694,9 +1694,9 @@ void FrameLoader::setFirstPartyForCookies(const KURL& url)
class HashChangeEventTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<HashChangeEventTask> create(PassRefPtr<Document> document)
+ static PassOwnPtr<HashChangeEventTask> create(PassRefPtr<Document> document)
{
- return adoptRef(new HashChangeEventTask(document));
+ return new HashChangeEventTask(document);
}
virtual void performTask(ScriptExecutionContext* context)
diff --git a/WebCore/loader/appcache/ApplicationCacheGroup.cpp b/WebCore/loader/appcache/ApplicationCacheGroup.cpp
index 1a223ce..958e820 100644
--- a/WebCore/loader/appcache/ApplicationCacheGroup.cpp
+++ b/WebCore/loader/appcache/ApplicationCacheGroup.cpp
@@ -947,9 +947,9 @@ void ApplicationCacheGroup::scheduleReachedMaxAppCacheSizeCallback()
class CallCacheListenerTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<CallCacheListenerTask> create(PassRefPtr<DocumentLoader> loader, ApplicationCacheHost::EventID eventID)
+ static PassOwnPtr<CallCacheListenerTask> create(PassRefPtr<DocumentLoader> loader, ApplicationCacheHost::EventID eventID)
{
- return adoptRef(new CallCacheListenerTask(loader, eventID));
+ return new CallCacheListenerTask(loader, eventID);
}
virtual void performTask(ScriptExecutionContext* context)
diff --git a/WebCore/storage/Database.cpp b/WebCore/storage/Database.cpp
index 29b9555..5c26c5b 100644
--- a/WebCore/storage/Database.cpp
+++ b/WebCore/storage/Database.cpp
@@ -208,9 +208,9 @@ bool Database::openAndVerifyVersion(ExceptionCode& e)
bool success = false;
DatabaseTaskSynchronizer synchronizer;
- RefPtr<DatabaseOpenTask> task = DatabaseOpenTask::create(this, &synchronizer, e, success);
+ OwnPtr<DatabaseOpenTask> task = DatabaseOpenTask::create(this, &synchronizer, e, success);
- m_document->databaseThread()->scheduleImmediateTask(task);
+ m_document->databaseThread()->scheduleImmediateTask(task.release());
synchronizer.waitForTaskCompletion();
return success;
@@ -319,9 +319,9 @@ void Database::markAsDeletedAndClose()
m_document->databaseThread()->unscheduleDatabaseTasks(this);
DatabaseTaskSynchronizer synchronizer;
- RefPtr<DatabaseCloseTask> task = DatabaseCloseTask::create(this, &synchronizer);
+ OwnPtr<DatabaseCloseTask> task = DatabaseCloseTask::create(this, &synchronizer);
- m_document->databaseThread()->scheduleImmediateTask(task);
+ m_document->databaseThread()->scheduleImmediateTask(task.release());
synchronizer.waitForTaskCompletion();
}
@@ -539,7 +539,7 @@ void Database::scheduleTransaction()
}
if (transaction && m_document->databaseThread()) {
- RefPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
+ OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
m_transactionInProgress = true;
m_document->databaseThread()->scheduleTask(task.release());
@@ -552,7 +552,7 @@ void Database::scheduleTransactionStep(SQLTransaction* transaction, bool immedia
if (!m_document->databaseThread())
return;
- RefPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
+ OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
if (immediately)
m_document->databaseThread()->scheduleImmediateTask(task.release());
@@ -629,9 +629,9 @@ Vector<String> Database::tableNames()
return result;
DatabaseTaskSynchronizer synchronizer;
- RefPtr<DatabaseTableNamesTask> task = DatabaseTableNamesTask::create(this, &synchronizer, result);
+ OwnPtr<DatabaseTableNamesTask> task = DatabaseTableNamesTask::create(this, &synchronizer, result);
- m_document->databaseThread()->scheduleImmediateTask(task);
+ m_document->databaseThread()->scheduleImmediateTask(task.release());
synchronizer.waitForTaskCompletion();
return result;
diff --git a/WebCore/storage/DatabaseTask.h b/WebCore/storage/DatabaseTask.h
index 65a55af..97a23c7 100644
--- a/WebCore/storage/DatabaseTask.h
+++ b/WebCore/storage/DatabaseTask.h
@@ -32,6 +32,7 @@
#include "ExceptionCode.h"
#include "PlatformString.h"
#include <wtf/OwnPtr.h>
+#include <wtf/PassOwnPtr.h>
#include <wtf/PassRefPtr.h>
#include <wtf/Threading.h>
#include <wtf/Vector.h>
@@ -65,7 +66,7 @@ private:
ThreadCondition m_synchronousCondition;
};
-class DatabaseTask : public ThreadSafeShared<DatabaseTask> {
+class DatabaseTask : public Noncopyable {
friend class Database;
public:
virtual ~DatabaseTask();
@@ -91,9 +92,9 @@ private:
class DatabaseOpenTask : public DatabaseTask {
public:
- static PassRefPtr<DatabaseOpenTask> create(Database* db, DatabaseTaskSynchronizer* synchronizer, ExceptionCode& code, bool& success)
+ static PassOwnPtr<DatabaseOpenTask> create(Database* db, DatabaseTaskSynchronizer* synchronizer, ExceptionCode& code, bool& success)
{
- return adoptRef(new DatabaseOpenTask(db, synchronizer, code, success));
+ return new DatabaseOpenTask(db, synchronizer, code, success);
}
private:
@@ -110,9 +111,9 @@ private:
class DatabaseCloseTask : public DatabaseTask {
public:
- static PassRefPtr<DatabaseCloseTask> create(Database* db, DatabaseTaskSynchronizer* synchronizer)
+ static PassOwnPtr<DatabaseCloseTask> create(Database* db, DatabaseTaskSynchronizer* synchronizer)
{
- return adoptRef(new DatabaseCloseTask(db, synchronizer));
+ return new DatabaseCloseTask(db, synchronizer);
}
private:
@@ -127,9 +128,9 @@ private:
class DatabaseTransactionTask : public DatabaseTask {
public:
// Transaction task is never synchronous, so no 'synchronizer' parameter.
- static PassRefPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransaction> transaction)
+ static PassOwnPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransaction> transaction)
{
- return adoptRef(new DatabaseTransactionTask(transaction));
+ return new DatabaseTransactionTask(transaction);
}
SQLTransaction* transaction() const { return m_transaction.get(); }
@@ -148,9 +149,9 @@ private:
class DatabaseTableNamesTask : public DatabaseTask {
public:
- static PassRefPtr<DatabaseTableNamesTask> create(Database* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
+ static PassOwnPtr<DatabaseTableNamesTask> create(Database* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
{
- return adoptRef(new DatabaseTableNamesTask(db, synchronizer, names));
+ return new DatabaseTableNamesTask(db, synchronizer, names);
}
private:
diff --git a/WebCore/storage/DatabaseThread.cpp b/WebCore/storage/DatabaseThread.cpp
index 40c83ee..12e9251 100644
--- a/WebCore/storage/DatabaseThread.cpp
+++ b/WebCore/storage/DatabaseThread.cpp
@@ -91,13 +91,8 @@ void* DatabaseThread::databaseThread()
}
AutodrainedPool pool;
- while (true) {
- RefPtr<DatabaseTask> task;
- if (!m_queue.waitForMessage(task))
- break;
-
+ while (OwnPtr<DatabaseTask> task = m_queue.waitForMessage()) {
task->performTask();
-
pool.cycle();
}
@@ -142,12 +137,12 @@ void DatabaseThread::recordDatabaseClosed(Database* database)
m_openDatabaseSet.remove(database);
}
-void DatabaseThread::scheduleTask(PassRefPtr<DatabaseTask> task)
+void DatabaseThread::scheduleTask(PassOwnPtr<DatabaseTask> task)
{
m_queue.append(task);
}
-void DatabaseThread::scheduleImmediateTask(PassRefPtr<DatabaseTask> task)
+void DatabaseThread::scheduleImmediateTask(PassOwnPtr<DatabaseTask> task)
{
m_queue.prepend(task);
}
@@ -155,7 +150,7 @@ void DatabaseThread::scheduleImmediateTask(PassRefPtr<DatabaseTask> task)
class SameDatabasePredicate {
public:
SameDatabasePredicate(const Database* database) : m_database(database) { }
- bool operator()(RefPtr<DatabaseTask>& task) const { return task->database() == m_database; }
+ bool operator()(DatabaseTask* task) const { return task->database() == m_database; }
private:
const Database* m_database;
};
diff --git a/WebCore/storage/DatabaseThread.h b/WebCore/storage/DatabaseThread.h
index 83b1baf..269a633 100644
--- a/WebCore/storage/DatabaseThread.h
+++ b/WebCore/storage/DatabaseThread.h
@@ -34,6 +34,7 @@
#include <wtf/HashSet.h>
#include <wtf/MessageQueue.h>
#include <wtf/OwnPtr.h>
+#include <wtf/PassOwnPtr.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/Threading.h>
@@ -55,8 +56,8 @@ public:
void requestTermination();
bool terminationRequested() const;
- void scheduleTask(PassRefPtr<DatabaseTask>);
- void scheduleImmediateTask(PassRefPtr<DatabaseTask>); // This just adds the task to the front of the queue - the caller needs to be extremely careful not to create deadlocks when waiting for completion.
+ void scheduleTask(PassOwnPtr<DatabaseTask>);
+ void scheduleImmediateTask(PassOwnPtr<DatabaseTask>); // This just adds the task to the front of the queue - the caller needs to be extremely careful not to create deadlocks when waiting for completion.
void unscheduleDatabaseTasks(Database*);
void recordDatabaseOpen(Database*);
@@ -76,7 +77,7 @@ private:
ThreadIdentifier m_threadID;
RefPtr<DatabaseThread> m_selfRef;
- MessageQueue<RefPtr<DatabaseTask> > m_queue;
+ MessageQueue<DatabaseTask> m_queue;
// This set keeps track of the open databases that have been used on this thread.
typedef HashSet<RefPtr<Database> > DatabaseSet;
diff --git a/WebCore/storage/LocalStorageTask.h b/WebCore/storage/LocalStorageTask.h
index f03d851..3256df7 100644
--- a/WebCore/storage/LocalStorageTask.h
+++ b/WebCore/storage/LocalStorageTask.h
@@ -28,8 +28,7 @@
#if ENABLE(DOM_STORAGE)
-#include <wtf/PassRefPtr.h>
-#include <wtf/RefPtr.h>
+#include <wtf/PassOwnPtr.h>
#include <wtf/Threading.h>
namespace WebCore {
@@ -44,9 +43,9 @@ namespace WebCore {
~LocalStorageTask();
- static PassRefPtr<LocalStorageTask> createImport(StorageAreaSync* area) { return adoptRef(new LocalStorageTask(AreaImport, area)); }
- static PassRefPtr<LocalStorageTask> createSync(StorageAreaSync* area) { return adoptRef(new LocalStorageTask(AreaSync, area)); }
- static PassRefPtr<LocalStorageTask> createTerminate(LocalStorageThread* thread) { return adoptRef(new LocalStorageTask(TerminateThread, thread)); }
+ static PassOwnPtr<LocalStorageTask> createImport(StorageAreaSync* area) { return new LocalStorageTask(AreaImport, area); }
+ static PassOwnPtr<LocalStorageTask> createSync(StorageAreaSync* area) { return new LocalStorageTask(AreaSync, area); }
+ static PassOwnPtr<LocalStorageTask> createTerminate(LocalStorageThread* thread) { return new LocalStorageTask(TerminateThread, thread); }
void performTask();
diff --git a/WebCore/storage/LocalStorageThread.cpp b/WebCore/storage/LocalStorageThread.cpp
index 9373232..005156b 100644
--- a/WebCore/storage/LocalStorageThread.cpp
+++ b/WebCore/storage/LocalStorageThread.cpp
@@ -69,13 +69,8 @@ void* LocalStorageThread::localStorageThread()
MutexLocker lock(m_threadCreationMutex);
}
- while (true) {
- RefPtr<LocalStorageTask> task;
- if (!m_queue.waitForMessage(task))
- break;
-
+ while (OwnPtr<LocalStorageTask> task = m_queue.waitForMessage())
task->performTask();
- }
// Detach the thread so its resources are no longer of any concern to anyone else
detachThread(m_threadID);
diff --git a/WebCore/storage/LocalStorageThread.h b/WebCore/storage/LocalStorageThread.h
index 8fef35d..616b809 100644
--- a/WebCore/storage/LocalStorageThread.h
+++ b/WebCore/storage/LocalStorageThread.h
@@ -63,7 +63,7 @@ namespace WebCore {
ThreadIdentifier m_threadID;
RefPtr<LocalStorageThread> m_selfRef;
- MessageQueue<RefPtr<LocalStorageTask> > m_queue;
+ MessageQueue<LocalStorageTask> m_queue;
Mutex m_terminateLock;
ThreadCondition m_terminateCondition;
diff --git a/WebCore/websockets/WebSocket.cpp b/WebCore/websockets/WebSocket.cpp
index 32e0559..d277465 100644
--- a/WebCore/websockets/WebSocket.cpp
+++ b/WebCore/websockets/WebSocket.cpp
@@ -52,9 +52,9 @@ namespace WebCore {
class ProcessWebSocketEventTask : public ScriptExecutionContext::Task {
public:
typedef void (WebSocket::*Method)(Event*);
- static PassRefPtr<ProcessWebSocketEventTask> create(PassRefPtr<WebSocket> webSocket, PassRefPtr<Event> event)
+ static PassOwnPtr<ProcessWebSocketEventTask> create(PassRefPtr<WebSocket> webSocket, PassRefPtr<Event> event)
{
- return adoptRef(new ProcessWebSocketEventTask(webSocket, event));
+ return new ProcessWebSocketEventTask(webSocket, event);
}
virtual void performTask(ScriptExecutionContext*)
{
diff --git a/WebCore/workers/DefaultSharedWorkerRepository.cpp b/WebCore/workers/DefaultSharedWorkerRepository.cpp
index 8b1a480..655b90e 100644
--- a/WebCore/workers/DefaultSharedWorkerRepository.cpp
+++ b/WebCore/workers/DefaultSharedWorkerRepository.cpp
@@ -73,8 +73,8 @@ public:
bool matches(const String& name, PassRefPtr<SecurityOrigin> origin, const KURL& urlToMatch) const;
// WorkerLoaderProxy
- virtual void postTaskToLoader(PassRefPtr<ScriptExecutionContext::Task>);
- virtual void postTaskForModeToWorkerContext(PassRefPtr<ScriptExecutionContext::Task>, const String&);
+ virtual void postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task>);
+ virtual void postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task>, const String&);
// WorkerReportingProxy
virtual void postExceptionToWorkerObject(const String& errorMessage, int lineNumber, const String& sourceURL);
@@ -128,7 +128,7 @@ bool SharedWorkerProxy::matches(const String& name, PassRefPtr<SecurityOrigin> o
return name == m_name;
}
-void SharedWorkerProxy::postTaskToLoader(PassRefPtr<ScriptExecutionContext::Task> task)
+void SharedWorkerProxy::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task)
{
MutexLocker lock(m_workerDocumentsLock);
@@ -144,7 +144,7 @@ void SharedWorkerProxy::postTaskToLoader(PassRefPtr<ScriptExecutionContext::Task
document->postTask(task);
}
-void SharedWorkerProxy::postTaskForModeToWorkerContext(PassRefPtr<ScriptExecutionContext::Task> task, const String& mode)
+void SharedWorkerProxy::postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
{
if (isClosing())
return;
@@ -221,9 +221,9 @@ void SharedWorkerProxy::close()
class SharedWorkerConnectTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<SharedWorkerConnectTask> create(PassOwnPtr<MessagePortChannel> channel)
+ static PassOwnPtr<SharedWorkerConnectTask> create(PassOwnPtr<MessagePortChannel> channel)
{
- return adoptRef(new SharedWorkerConnectTask(channel));
+ return new SharedWorkerConnectTask(channel);
}
private:
diff --git a/WebCore/workers/GenericWorkerTask.h b/WebCore/workers/GenericWorkerTask.h
index d6a9994..27694c4 100644
--- a/WebCore/workers/GenericWorkerTask.h
+++ b/WebCore/workers/GenericWorkerTask.h
@@ -70,9 +70,9 @@ namespace WebCore {
typedef GenericWorkerTask1<P1, MP1> GenericWorkerTask;
typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1)
{
- return adoptRef(new GenericWorkerTask(method, parameter1));
+ return new GenericWorkerTask(method, parameter1);
}
private:
@@ -100,9 +100,9 @@ namespace WebCore {
typedef typename GenericWorkerTaskTraits<P1>::ParamType Param1;
typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2)
{
- return adoptRef(new GenericWorkerTask(method, parameter1, parameter2));
+ return new GenericWorkerTask(method, parameter1, parameter2);
}
private:
@@ -133,9 +133,9 @@ namespace WebCore {
typedef typename GenericWorkerTaskTraits<P2>::ParamType Param2;
typedef typename GenericWorkerTaskTraits<P3>::ParamType Param3;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
{
- return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3));
+ return new GenericWorkerTask(method, parameter1, parameter2, parameter3);
}
private:
@@ -169,9 +169,9 @@ namespace WebCore {
typedef typename GenericWorkerTaskTraits<P3>::ParamType Param3;
typedef typename GenericWorkerTaskTraits<P4>::ParamType Param4;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4)
{
- return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4));
+ return new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4);
}
private:
@@ -208,9 +208,9 @@ namespace WebCore {
typedef typename GenericWorkerTaskTraits<P4>::ParamType Param4;
typedef typename GenericWorkerTaskTraits<P5>::ParamType Param5;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5)
{
- return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5));
+ return new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5);
}
private:
@@ -250,9 +250,9 @@ namespace WebCore {
typedef typename GenericWorkerTaskTraits<P5>::ParamType Param5;
typedef typename GenericWorkerTaskTraits<P6>::ParamType Param6;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6)
{
- return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6));
+ return new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6);
}
private:
@@ -295,9 +295,9 @@ namespace WebCore {
typedef typename GenericWorkerTaskTraits<P6>::ParamType Param6;
typedef typename GenericWorkerTaskTraits<P7>::ParamType Param7;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7)
{
- return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6, parameter7));
+ return new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6, parameter7);
}
private:
@@ -343,9 +343,9 @@ namespace WebCore {
typedef typename GenericWorkerTaskTraits<P7>::ParamType Param7;
typedef typename GenericWorkerTaskTraits<P8>::ParamType Param8;
- static PassRefPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7, Param8 parameter8)
+ static PassOwnPtr<GenericWorkerTask> create(Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3, Param4 parameter4, Param5 parameter5, Param6 parameter6, Param7 parameter7, Param8 parameter8)
{
- return adoptRef(new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6, parameter7, parameter8));
+ return new GenericWorkerTask(method, parameter1, parameter2, parameter3, parameter4, parameter5, parameter6, parameter7, parameter8);
}
private:
@@ -380,7 +380,7 @@ namespace WebCore {
};
template<typename P1, typename MP1>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1),
const P1& parameter1)
{
@@ -390,7 +390,7 @@ namespace WebCore {
}
template<typename P1, typename MP1, typename P2, typename MP2>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1, MP2),
const P1& parameter1, const P2& parameter2)
{
@@ -400,7 +400,7 @@ namespace WebCore {
}
template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1, MP2, MP3),
const P1& parameter1, const P2& parameter2, const P3& parameter3)
{
@@ -411,7 +411,7 @@ namespace WebCore {
}
template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4),
const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4)
{
@@ -423,7 +423,7 @@ namespace WebCore {
}
template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5),
const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5)
{
@@ -436,7 +436,7 @@ namespace WebCore {
}
template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5, typename P6, typename MP6>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5, MP6),
const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6)
{
@@ -449,7 +449,7 @@ namespace WebCore {
}
template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5, typename P6, typename MP6, typename P7, typename MP7>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5, MP6, MP7),
const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6, const P7& parameter7)
{
@@ -464,7 +464,7 @@ namespace WebCore {
}
template<typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5, typename P6, typename MP6, typename P7, typename MP7, typename P8, typename MP8>
- PassRefPtr<ScriptExecutionContext::Task> createCallbackTask(
+ PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
void (*method)(ScriptExecutionContext*, MP1, MP2, MP3, MP4, MP5, MP6, MP7, MP8),
const P1& parameter1, const P2& parameter2, const P3& parameter3, const P4& parameter4, const P5& parameter5, const P6& parameter6, const P7& parameter7, const P8& parameter8)
{
diff --git a/WebCore/workers/WorkerContext.cpp b/WebCore/workers/WorkerContext.cpp
index 9a88309..e823278 100644
--- a/WebCore/workers/WorkerContext.cpp
+++ b/WebCore/workers/WorkerContext.cpp
@@ -162,7 +162,7 @@ void WorkerContext::scriptImported(unsigned long, const String&)
notImplemented();
}
-void WorkerContext::postTask(PassRefPtr<Task> task)
+void WorkerContext::postTask(PassOwnPtr<Task> task)
{
thread()->runLoop().postTask(task);
}
diff --git a/WebCore/workers/WorkerContext.h b/WebCore/workers/WorkerContext.h
index 9725cf7..f37d42c 100644
--- a/WebCore/workers/WorkerContext.h
+++ b/WebCore/workers/WorkerContext.h
@@ -74,7 +74,7 @@ namespace WebCore {
virtual void resourceRetrievedByXMLHttpRequest(unsigned long identifier, const ScriptString& sourceString);
virtual void scriptImported(unsigned long identifier, const String& sourceString);
- virtual void postTask(PassRefPtr<Task>); // Executes the task on context's thread asynchronously.
+ virtual void postTask(PassOwnPtr<Task>); // Executes the task on context's thread asynchronously.
// WorkerGlobalScope
WorkerContext* self() { return this; }
diff --git a/WebCore/workers/WorkerLoaderProxy.h b/WebCore/workers/WorkerLoaderProxy.h
index ac7cda1..fe1bf51 100644
--- a/WebCore/workers/WorkerLoaderProxy.h
+++ b/WebCore/workers/WorkerLoaderProxy.h
@@ -34,7 +34,7 @@
#if ENABLE(WORKERS)
#include "ScriptExecutionContext.h"
-#include <wtf/PassRefPtr.h>
+#include <wtf/PassOwnPtr.h>
namespace WebCore {
@@ -50,11 +50,11 @@ namespace WebCore {
virtual ~WorkerLoaderProxy() { }
// Posts a task to the thread which runs the loading code (normally, the main thread).
- virtual void postTaskToLoader(PassRefPtr<ScriptExecutionContext::Task>) = 0;
+ virtual void postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task>) = 0;
// Posts callbacks from loading code to the WorkerContext. The 'mode' is used to differentiate
// specific synchronous loading requests so they can be 'nested', per spec.
- virtual void postTaskForModeToWorkerContext(PassRefPtr<ScriptExecutionContext::Task>, const String& mode) = 0;
+ virtual void postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task>, const String& mode) = 0;
};
} // namespace WebCore
diff --git a/WebCore/workers/WorkerMessagingProxy.cpp b/WebCore/workers/WorkerMessagingProxy.cpp
index 0b66694..2e1dfe0 100644
--- a/WebCore/workers/WorkerMessagingProxy.cpp
+++ b/WebCore/workers/WorkerMessagingProxy.cpp
@@ -46,9 +46,9 @@ namespace WebCore {
class MessageWorkerContextTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<MessageWorkerContextTask> create(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels)
+ static PassOwnPtr<MessageWorkerContextTask> create(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels)
{
- return adoptRef(new MessageWorkerContextTask(message, channels));
+ return new MessageWorkerContextTask(message, channels);
}
private:
@@ -74,9 +74,9 @@ private:
class MessageWorkerTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<MessageWorkerTask> create(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels, WorkerMessagingProxy* messagingProxy)
+ static PassOwnPtr<MessageWorkerTask> create(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels, WorkerMessagingProxy* messagingProxy)
{
- return adoptRef(new MessageWorkerTask(message, channels, messagingProxy));
+ return new MessageWorkerTask(message, channels, messagingProxy);
}
private:
@@ -105,9 +105,9 @@ private:
class WorkerExceptionTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<WorkerExceptionTask> create(const String& errorMessage, int lineNumber, const String& sourceURL, WorkerMessagingProxy* messagingProxy)
+ static PassOwnPtr<WorkerExceptionTask> create(const String& errorMessage, int lineNumber, const String& sourceURL, WorkerMessagingProxy* messagingProxy)
{
- return adoptRef(new WorkerExceptionTask(errorMessage, lineNumber, sourceURL, messagingProxy));
+ return new WorkerExceptionTask(errorMessage, lineNumber, sourceURL, messagingProxy);
}
private:
@@ -141,9 +141,9 @@ private:
class WorkerContextDestroyedTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<WorkerContextDestroyedTask> create(WorkerMessagingProxy* messagingProxy)
+ static PassOwnPtr<WorkerContextDestroyedTask> create(WorkerMessagingProxy* messagingProxy)
{
- return adoptRef(new WorkerContextDestroyedTask(messagingProxy));
+ return new WorkerContextDestroyedTask(messagingProxy);
}
private:
@@ -162,9 +162,9 @@ private:
class WorkerTerminateTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<WorkerTerminateTask> create(WorkerMessagingProxy* messagingProxy)
+ static PassOwnPtr<WorkerTerminateTask> create(WorkerMessagingProxy* messagingProxy)
{
- return adoptRef(new WorkerTerminateTask(messagingProxy));
+ return new WorkerTerminateTask(messagingProxy);
}
private:
@@ -183,9 +183,9 @@ private:
class WorkerThreadActivityReportTask : public ScriptExecutionContext::Task {
public:
- static PassRefPtr<WorkerThreadActivityReportTask> create(WorkerMessagingProxy* messagingProxy, bool confirmingMessage, bool hasPendingActivity)
+ static PassOwnPtr<WorkerThreadActivityReportTask> create(WorkerMessagingProxy* messagingProxy, bool confirmingMessage, bool hasPendingActivity)
{
- return adoptRef(new WorkerThreadActivityReportTask(messagingProxy, confirmingMessage, hasPendingActivity));
+ return new WorkerThreadActivityReportTask(messagingProxy, confirmingMessage, hasPendingActivity);
}
private:
@@ -257,7 +257,7 @@ void WorkerMessagingProxy::postMessageToWorkerContext(PassRefPtr<SerializedScrip
m_queuedEarlyTasks.append(MessageWorkerContextTask::create(message, channels.release()));
}
-void WorkerMessagingProxy::postTaskForModeToWorkerContext(PassRefPtr<ScriptExecutionContext::Task> task, const String& mode)
+void WorkerMessagingProxy::postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
{
if (m_askedToTerminate)
return;
@@ -266,7 +266,7 @@ void WorkerMessagingProxy::postTaskForModeToWorkerContext(PassRefPtr<ScriptExecu
m_workerThread->runLoop().postTaskForMode(task, mode);
}
-void WorkerMessagingProxy::postTaskToLoader(PassRefPtr<ScriptExecutionContext::Task> task)
+void WorkerMessagingProxy::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task)
{
// FIXME: In case of nested workers, this should go directly to the root Document context.
ASSERT(m_scriptExecutionContext->isDocument());
@@ -304,7 +304,7 @@ void WorkerMessagingProxy::workerThreadCreated(PassRefPtr<DedicatedWorkerThread>
m_workerThreadHadPendingActivity = true; // Worker initialization means a pending activity.
for (unsigned i = 0; i < taskCount; ++i)
- m_workerThread->runLoop().postTask(m_queuedEarlyTasks[i]);
+ m_workerThread->runLoop().postTask(m_queuedEarlyTasks[i].release());
m_queuedEarlyTasks.clear();
}
}
diff --git a/WebCore/workers/WorkerMessagingProxy.h b/WebCore/workers/WorkerMessagingProxy.h
index 754102a..90b87f4 100644
--- a/WebCore/workers/WorkerMessagingProxy.h
+++ b/WebCore/workers/WorkerMessagingProxy.h
@@ -71,8 +71,8 @@ namespace WebCore {
// Implementation of WorkerLoaderProxy.
// These methods are called on different threads to schedule loading
// requests and to send callbacks back to WorkerContext.
- virtual void postTaskToLoader(PassRefPtr<ScriptExecutionContext::Task>);
- virtual void postTaskForModeToWorkerContext(PassRefPtr<ScriptExecutionContext::Task>, const String& mode);
+ virtual void postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task>);
+ virtual void postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task>, const String& mode);
void workerThreadCreated(PassRefPtr<DedicatedWorkerThread>);
@@ -100,7 +100,7 @@ namespace WebCore {
bool m_askedToTerminate;
- Vector<RefPtr<ScriptExecutionContext::Task> > m_queuedEarlyTasks; // Tasks are queued here until there's a thread object created.
+ Vector<OwnPtr<ScriptExecutionContext::Task> > m_queuedEarlyTasks; // Tasks are queued here until there's a thread object created.
};
} // namespace WebCore
diff --git a/WebCore/workers/WorkerRunLoop.cpp b/WebCore/workers/WorkerRunLoop.cpp
index 39b21c6..445fa65 100644
--- a/WebCore/workers/WorkerRunLoop.cpp
+++ b/WebCore/workers/WorkerRunLoop.cpp
@@ -64,27 +64,6 @@ private:
double m_nextFireTime;
};
-class WorkerRunLoop::Task : public RefCounted<Task> {
-public:
- static PassRefPtr<Task> create(PassRefPtr<ScriptExecutionContext::Task> task, const String& mode)
- {
- return adoptRef(new Task(task, mode));
- }
-
- const String& mode() const { return m_mode; }
- void performTask(ScriptExecutionContext* context) { m_task->performTask(context); }
-
-private:
- Task(PassRefPtr<ScriptExecutionContext::Task> task, const String& mode)
- : m_task(task)
- , m_mode(mode.crossThreadString())
- {
- }
-
- RefPtr<ScriptExecutionContext::Task> m_task;
- String m_mode;
-};
-
class ModePredicate {
public:
ModePredicate(const String& mode)
@@ -98,7 +77,7 @@ public:
return m_defaultMode;
}
- bool operator()(PassRefPtr<WorkerRunLoop::Task> task) const
+ bool operator()(WorkerRunLoop::Task* task) const
{
return m_defaultMode || m_mode == task->mode();
}
@@ -169,9 +148,9 @@ MessageQueueWaitResult WorkerRunLoop::runInMode(WorkerContext* context, const Mo
ASSERT(context->thread());
ASSERT(context->thread()->threadID() == currentThread());
- double absoluteTime = (predicate.isDefaultMode() && m_sharedTimer->isActive()) ? m_sharedTimer->fireTime() : MessageQueue<RefPtr<Task> >::infiniteTime();
- RefPtr<Task> task;
- MessageQueueWaitResult result = m_messageQueue.waitForMessageFilteredWithTimeout(task, predicate, absoluteTime);
+ double absoluteTime = (predicate.isDefaultMode() && m_sharedTimer->isActive()) ? m_sharedTimer->fireTime() : MessageQueue<Task>::infiniteTime();
+ MessageQueueWaitResult result;
+ OwnPtr<WorkerRunLoop::Task> task = m_messageQueue.waitForMessageFilteredWithTimeout(result, predicate, absoluteTime);
// If the context is closing, don't dispatch any further tasks (per section 4.1.1 of the Web Workers spec).
if (context->isClosing())
@@ -198,16 +177,33 @@ void WorkerRunLoop::terminate()
m_messageQueue.kill();
}
-void WorkerRunLoop::postTask(PassRefPtr<ScriptExecutionContext::Task> task)
+void WorkerRunLoop::postTask(PassOwnPtr<ScriptExecutionContext::Task> task)
{
postTaskForMode(task, defaultMode());
}
-void WorkerRunLoop::postTaskForMode(PassRefPtr<ScriptExecutionContext::Task> task, const String& mode)
+void WorkerRunLoop::postTaskForMode(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
{
m_messageQueue.append(Task::create(task, mode.crossThreadString()));
}
+PassOwnPtr<WorkerRunLoop::Task> WorkerRunLoop::Task::create(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
+{
+ return new Task(task, mode);
+}
+
+void WorkerRunLoop::Task::performTask(ScriptExecutionContext* context)
+{
+ m_task->performTask(context);
+}
+
+WorkerRunLoop::Task::Task(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
+ : m_task(task)
+ , m_mode(mode.crossThreadString())
+{
+}
+
+
} // namespace WebCore
#endif // ENABLE(WORKERS)
diff --git a/WebCore/workers/WorkerRunLoop.h b/WebCore/workers/WorkerRunLoop.h
index 5f74f01..9d4edfd 100644
--- a/WebCore/workers/WorkerRunLoop.h
+++ b/WebCore/workers/WorkerRunLoop.h
@@ -36,7 +36,7 @@
#include "ScriptExecutionContext.h"
#include <wtf/MessageQueue.h>
#include <wtf/OwnPtr.h>
-#include <wtf/PassRefPtr.h>
+#include <wtf/PassOwnPtr.h>
namespace WebCore {
@@ -58,18 +58,32 @@ namespace WebCore {
void terminate();
bool terminated() { return m_messageQueue.killed(); }
- void postTask(PassRefPtr<ScriptExecutionContext::Task>);
- void postTaskForMode(PassRefPtr<ScriptExecutionContext::Task>, const String& mode);
+ void postTask(PassOwnPtr<ScriptExecutionContext::Task>);
+ void postTaskForMode(PassOwnPtr<ScriptExecutionContext::Task>, const String& mode);
unsigned long createUniqueId() { return ++m_uniqueId; }
static String defaultMode();
- class Task;
+
+ class Task : public Noncopyable {
+ public:
+ static PassOwnPtr<Task> create(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode);
+ ~Task() { }
+ const String& mode() const { return m_mode; }
+ void performTask(ScriptExecutionContext* context);
+
+ private:
+ Task(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode);
+
+ OwnPtr<ScriptExecutionContext::Task> m_task;
+ String m_mode;
+ };
+
private:
friend class RunLoopSetup;
MessageQueueWaitResult runInMode(WorkerContext*, const ModePredicate&);
- MessageQueue<RefPtr<Task> > m_messageQueue;
+ MessageQueue<Task> m_messageQueue;
OwnPtr<WorkerSharedTimer> m_sharedTimer;
int m_nestedCount;
unsigned long m_uniqueId;
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list