Changeset 156972 in webkit


Ignore:
Timestamp:
Oct 5, 2013 2:53:59 PM (11 years ago)
Author:
andersca@apple.com
Message:

Clean up MessageQueue.h
​https://bugs.webkit.org/show_bug.cgi?id=122392

Reviewed by Andreas Kling.

Source/WebCore:

Update for changes to MessageQueue, mostly changing create functions to return std::unique_ptr.
I intentionally avoided using std::make_unique in a couple of places because I didn't want to make nested classes
public, and I believe that we can change some of this code to use std::function.

  • Modules/webaudio/AsyncAudioDecoder.cpp:

(WebCore::AsyncAudioDecoder::decodeAsync):
(WebCore::AsyncAudioDecoder::runLoop):
(WebCore::AsyncAudioDecoder::DecodingTask::create):

  • Modules/webaudio/AsyncAudioDecoder.h:
  • Modules/webdatabase/Database.cpp:

(WebCore::Database::markAsDeletedAndClose):
(WebCore::Database::tableNames):

  • Modules/webdatabase/DatabaseBackend.cpp:

(WebCore::DatabaseBackend::openAndVerifyVersion):
(WebCore::DatabaseBackend::scheduleTransaction):
(WebCore::DatabaseBackend::scheduleTransactionStep):

  • Modules/webdatabase/DatabaseTask.h:

(WebCore::DatabaseBackend::DatabaseOpenTask::create):
(WebCore::DatabaseBackend::DatabaseCloseTask::create):
(WebCore::DatabaseBackend::DatabaseTransactionTask::create):
(WebCore::DatabaseBackend::DatabaseTableNamesTask::create):

  • Modules/webdatabase/DatabaseThread.cpp:

(WebCore::DatabaseThread::databaseThread):
(WebCore::DatabaseThread::scheduleTask):
(WebCore::DatabaseThread::scheduleImmediateTask):
(WebCore::SameDatabasePredicate::operator()):

  • Modules/webdatabase/DatabaseThread.h:
  • dom/default/PlatformMessagePortChannel.cpp:

(WebCore::PlatformMessagePortChannel::EventData::create):
(WebCore::MessagePortChannel::tryGetMessageFromRemote):

  • dom/default/PlatformMessagePortChannel.h:

(WebCore::PlatformMessagePortChannel::MessagePortQueue::tryGetMessage):
(WebCore::PlatformMessagePortChannel::MessagePortQueue::appendAndCheckEmpty):

  • fileapi/FileThread.cpp:

(WebCore::FileThread::postTask):
(WebCore::SameInstancePredicate::operator()):
(WebCore::FileThread::runLoop):

  • fileapi/FileThread.h:
  • fileapi/FileThreadTask.h:

(WebCore::createFileThreadTask):

  • storage/StorageThread.cpp:

(WebCore::StorageThread::threadEntryPoint):
(WebCore::StorageThread::dispatch):
(WebCore::StorageThread::terminate):

  • workers/WorkerRunLoop.cpp:

(WebCore::ModePredicate::operator()):
(WebCore::WorkerRunLoop::runInMode):
(WebCore::WorkerRunLoop::runCleanupTasks):
(WebCore::WorkerRunLoop::Task::create):

  • workers/WorkerRunLoop.h:

Source/WTF:

Make MessageQueue use std::unique_ptr and change findIf and removeIf to take const references.

  • wtf/Deque.h:

Change findIf to take an rvalue reference.

  • wtf/MessageQueue.h:

(WTF::::append):
(WTF::::appendAndKill):
(WTF::::appendAndCheckEmpty):
(WTF::::prepend):
(WTF::::removeIf):

Location:
trunk/Source
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r156969 r156972  
     12013-10-05  Anders Carlsson  <andersca@apple.com>
     2
     3        Clean up MessageQueue.h
     4        https://bugs.webkit.org/show_bug.cgi?id=122392
     5
     6        Reviewed by Andreas Kling.
     7
     8        Make MessageQueue use std::unique_ptr and change findIf and removeIf to take const references.
     9
     10        * wtf/Deque.h:
     11        Change findIf to take an rvalue reference.
     12
     13        * wtf/MessageQueue.h:
     14        (WTF::::append):
     15        (WTF::::appendAndKill):
     16        (WTF::::appendAndCheckEmpty):
     17        (WTF::::prepend):
     18        (WTF::::removeIf):
     19
    1202013-10-05  Anders Carlsson  <andersca@apple.com>
    221

  • trunk/Source/WTF/wtf/Deque.h

    r155898 r156972  
    8989
    9090        template<typename Predicate>
    91         iterator findIf(Predicate&);
     91        iterator findIf(Predicate&&);
    9292
    9393    private:
    … …  
    354354    template<typename T, size_t inlineCapacity>
    355355    template<typename Predicate>
    356     inline auto Deque<T, inlineCapacity>::findIf(Predicate& predicate) -> iterator
     356    inline auto Deque<T, inlineCapacity>::findIf(Predicate&& predicate) -> iterator
    357357    {
    358358        iterator end_iterator = end();

  • trunk/Source/WTF/wtf/MessageQueue.h

    r155900 r156972  
    4747    // The queue takes ownership of messages and transfer it to the new owner
    4848    // when messages are fetched from the queue.
    49     // Essentially, MessageQueue acts as a queue of OwnPtr<DataType>.
     49    // Essentially, MessageQueue acts as a queue of std::unique_ptr<DataType>.
    5050    template<typename DataType>
    5151    class MessageQueue {
    … …  
    5555        ~MessageQueue();
    5656
    57         void append(OwnPtr<DataType>);
    58         void appendAndKill(OwnPtr<DataType>);
    59         bool appendAndCheckEmpty(OwnPtr<DataType>);
    60         void prepend(OwnPtr<DataType>);
    61 
    62         OwnPtr<DataType> waitForMessage();
    63         OwnPtr<DataType> tryGetMessage();
    64         OwnPtr<DataType> tryGetMessageIgnoringKilled();
     57        void append(std::unique_ptr<DataType>);
     58        void appendAndKill(std::unique_ptr<DataType>);
     59        bool appendAndCheckEmpty(std::unique_ptr<DataType>);
     60        void prepend(std::unique_ptr<DataType>);
     61
     62        std::unique_ptr<DataType> waitForMessage();
     63        std::unique_ptr<DataType> tryGetMessage();
     64        std::unique_ptr<DataType> tryGetMessageIgnoringKilled();
    6565        template<typename Predicate>
    66         OwnPtr<DataType> waitForMessageFilteredWithTimeout(MessageQueueWaitResult&, Predicate&, double absoluteTime);
     66        std::unique_ptr<DataType> waitForMessageFilteredWithTimeout(MessageQueueWaitResult&, Predicate&&, double absoluteTime);
    6767
    6868        template<typename Predicate>
    69         void removeIf(Predicate&);
     69        void removeIf(Predicate&&);
    7070
    7171        void kill();
    … …  
    7878
    7979    private:
    80         static bool alwaysTruePredicate(const OwnPtr<DataType>&) { return true; }
    81 
    8280        mutable Mutex m_mutex;
    8381        ThreadCondition m_condition;
    84         Deque<OwnPtr<DataType>> m_queue;
     82        Deque<std::unique_ptr<DataType>> m_queue;
    8583        bool m_killed;
    8684    };
    … …  
    9290
    9391    template<typename DataType>
    94     inline void MessageQueue<DataType>::append(OwnPtr<DataType> message)
     92    inline void MessageQueue<DataType>::append(std::unique_ptr<DataType> message)
    9593    {
    9694        MutexLocker lock(m_mutex);
    … …  
    10098
    10199    template<typename DataType>
    102     inline void MessageQueue<DataType>::appendAndKill(OwnPtr<DataType> message)
     100    inline void MessageQueue<DataType>::appendAndKill(std::unique_ptr<DataType> message)
    103101    {
    104102        MutexLocker lock(m_mutex);
    … …  
    110108    // Returns true if the queue was empty before the item was added.
    111109    template<typename DataType>
    112     inline bool MessageQueue<DataType>::appendAndCheckEmpty(OwnPtr<DataType> message)
     110    inline bool MessageQueue<DataType>::appendAndCheckEmpty(std::unique_ptr<DataType> message)
    113111    {
    114112        MutexLocker lock(m_mutex);
    … …  
    120118
    121119    template<typename DataType>
    122     inline void MessageQueue<DataType>::prepend(OwnPtr<DataType> message)
     120    inline void MessageQueue<DataType>::prepend(std::unique_ptr<DataType> message)
    123121    {
    124122        MutexLocker lock(m_mutex);
    … …  
    128126
    129127    template<typename DataType>
    130     inline auto MessageQueue<DataType>::waitForMessage() -> OwnPtr<DataType>
     128    inline auto MessageQueue<DataType>::waitForMessage() -> std::unique_ptr<DataType>
    131129    {
    132130        MessageQueueWaitResult exitReason;
    133         OwnPtr<DataType> result = waitForMessageFilteredWithTimeout(exitReason, MessageQueue<DataType>::alwaysTruePredicate, infiniteTime());
     131        std::unique_ptr<DataType> result = waitForMessageFilteredWithTimeout(exitReason, [](const DataType&) { return true; }, infiniteTime());
    134132        ASSERT(exitReason == MessageQueueTerminated || exitReason == MessageQueueMessageReceived);
    135133        return result;
    … …  
    138136    template<typename DataType>
    139137    template<typename Predicate>
    140     inline auto MessageQueue<DataType>::waitForMessageFilteredWithTimeout(MessageQueueWaitResult& result, Predicate& predicate, double absoluteTime) -> OwnPtr<DataType>
     138    inline auto MessageQueue<DataType>::waitForMessageFilteredWithTimeout(MessageQueueWaitResult& result, Predicate&& predicate, double absoluteTime) -> std::unique_ptr<DataType>
    141139    {
    142140        MutexLocker lock(m_mutex);
    … …  
    144142
    145143        auto found = m_queue.end();
    146         while (!m_killed && !timedOut && (found = m_queue.findIf(predicate)) == m_queue.end())
     144        while (!m_killed && !timedOut) {
     145            found = m_queue.findIf([&predicate](const std::unique_ptr<DataType>& ptr) -> bool {
     146                ASSERT(ptr);
     147                return predicate(*ptr);
     148            });
     149            if (found != m_queue.end())
     150                break;
     151
    147152            timedOut = !m_condition.timedWait(m_mutex, absoluteTime);
     153        }
    148154
    149155        ASSERT(!timedOut || absoluteTime != infiniteTime());
    … …  
    160166
    161167        ASSERT(found != m_queue.end());
    162         OwnPtr<DataType> message = std::move(*found);
     168        std::unique_ptr<DataType> message = std::move(*found);
    163169        m_queue.remove(found);
    164170        result = MessageQueueMessageReceived;
    … …  
    167173
    168174    template<typename DataType>
    169     inline auto MessageQueue<DataType>::tryGetMessage() -> OwnPtr<DataType>
     175    inline auto MessageQueue<DataType>::tryGetMessage() -> std::unique_ptr<DataType>
    170176    {
    171177        MutexLocker lock(m_mutex);
    … …  
    179185
    180186    template<typename DataType>
    181     inline auto MessageQueue<DataType>::tryGetMessageIgnoringKilled() -> OwnPtr<DataType>
     187    inline auto MessageQueue<DataType>::tryGetMessageIgnoringKilled() -> std::unique_ptr<DataType>
    182188    {
    183189        MutexLocker lock(m_mutex);
    … …  
    190196    template<typename DataType>
    191197    template<typename Predicate>
    192     inline void MessageQueue<DataType>::removeIf(Predicate& predicate)
    193     {
    194         MutexLocker lock(m_mutex);
    195         auto found = m_queue.end();
    196         // FIXME: I think the predicate here should really take a const DataType&
    197         // instead of a const OwnPtr<DataType>&.
    198         while ((found = m_queue.findIf(predicate)) != m_queue.end()) {
    199             OwnPtr<DataType> message = std::move(*found);
     198    inline void MessageQueue<DataType>::removeIf(Predicate&& predicate)
     199    {
     200        MutexLocker lock(m_mutex);
     201        while (true) {
     202            auto found = m_queue.findIf([&predicate](const std::unique_ptr<DataType>& ptr) -> bool {
     203                ASSERT(ptr);
     204                return predicate(*ptr);
     205            });
     206
     207            if (found == m_queue.end())
     208                break;
     209
    200210            m_queue.remove(found);
    201211        }

  • trunk/Source/WebCore/ChangeLog

    r156971 r156972  
     12013-10-05  Anders Carlsson  <andersca@apple.com>
     2
     3        Clean up MessageQueue.h
     4        https://bugs.webkit.org/show_bug.cgi?id=122392
     5
     6        Reviewed by Andreas Kling.
     7
     8        Update for changes to MessageQueue, mostly changing create functions to return std::unique_ptr.
     9        I intentionally avoided using std::make_unique in a couple of places because I didn't want to make nested classes
     10        public, and I believe that we can change some of this code to use std::function.
     11
     12        * Modules/webaudio/AsyncAudioDecoder.cpp:
     13        (WebCore::AsyncAudioDecoder::decodeAsync):
     14        (WebCore::AsyncAudioDecoder::runLoop):
     15        (WebCore::AsyncAudioDecoder::DecodingTask::create):
     16        * Modules/webaudio/AsyncAudioDecoder.h:
     17        * Modules/webdatabase/Database.cpp:
     18        (WebCore::Database::markAsDeletedAndClose):
     19        (WebCore::Database::tableNames):
     20        * Modules/webdatabase/DatabaseBackend.cpp:
     21        (WebCore::DatabaseBackend::openAndVerifyVersion):
     22        (WebCore::DatabaseBackend::scheduleTransaction):
     23        (WebCore::DatabaseBackend::scheduleTransactionStep):
     24        * Modules/webdatabase/DatabaseTask.h:
     25        (WebCore::DatabaseBackend::DatabaseOpenTask::create):
     26        (WebCore::DatabaseBackend::DatabaseCloseTask::create):
     27        (WebCore::DatabaseBackend::DatabaseTransactionTask::create):
     28        (WebCore::DatabaseBackend::DatabaseTableNamesTask::create):
     29        * Modules/webdatabase/DatabaseThread.cpp:
     30        (WebCore::DatabaseThread::databaseThread):
     31        (WebCore::DatabaseThread::scheduleTask):
     32        (WebCore::DatabaseThread::scheduleImmediateTask):
     33        (WebCore::SameDatabasePredicate::operator()):
     34        * Modules/webdatabase/DatabaseThread.h:
     35        * dom/default/PlatformMessagePortChannel.cpp:
     36        (WebCore::PlatformMessagePortChannel::EventData::create):
     37        (WebCore::MessagePortChannel::tryGetMessageFromRemote):
     38        * dom/default/PlatformMessagePortChannel.h:
     39        (WebCore::PlatformMessagePortChannel::MessagePortQueue::tryGetMessage):
     40        (WebCore::PlatformMessagePortChannel::MessagePortQueue::appendAndCheckEmpty):
     41        * fileapi/FileThread.cpp:
     42        (WebCore::FileThread::postTask):
     43        (WebCore::SameInstancePredicate::operator()):
     44        (WebCore::FileThread::runLoop):
     45        * fileapi/FileThread.h:
     46        * fileapi/FileThreadTask.h:
     47        (WebCore::createFileThreadTask):
     48        * storage/StorageThread.cpp:
     49        (WebCore::StorageThread::threadEntryPoint):
     50        (WebCore::StorageThread::dispatch):
     51        (WebCore::StorageThread::terminate):
     52        * workers/WorkerRunLoop.cpp:
     53        (WebCore::ModePredicate::operator()):
     54        (WebCore::WorkerRunLoop::runInMode):
     55        (WebCore::WorkerRunLoop::runCleanupTasks):
     56        (WebCore::WorkerRunLoop::Task::create):
     57        * workers/WorkerRunLoop.h:
     58
    1592013-10-04  Dean Jackson  <dino@apple.com>
    260

  • trunk/Source/WebCore/Modules/webaudio/AsyncAudioDecoder.cpp

    r153728 r156972  
    6161        return;
    6262
    63     OwnPtr<DecodingTask> decodingTask = DecodingTask::create(audioData, sampleRate, successCallback, errorCallback);
    64     m_queue.append(decodingTask.release()); // note that ownership of the task is effectively taken by the queue.
     63    auto decodingTask = DecodingTask::create(audioData, sampleRate, successCallback, errorCallback);
     64    m_queue.append(std::move(decodingTask)); // note that ownership of the task is effectively taken by the queue.
    6565}
    6666
    … …  
    8383
    8484    // Keep running decoding tasks until we're killed.
    85     while (OwnPtr<DecodingTask> decodingTask = m_queue.waitForMessage()) {
     85    while (auto decodingTask = m_queue.waitForMessage()) {
    8686        // Let the task take care of its own ownership.
    8787        // See DecodingTask::notifyComplete() for cleanup.
    88         decodingTask.leakPtr()->decode();
     88        decodingTask.release()->decode();
    8989    }
    9090}
    9191
    92 PassOwnPtr<AsyncAudioDecoder::DecodingTask> AsyncAudioDecoder::DecodingTask::create(ArrayBuffer* audioData, float sampleRate, PassRefPtr<AudioBufferCallback> successCallback, PassRefPtr<AudioBufferCallback> errorCallback)
     92std::unique_ptr<AsyncAudioDecoder::DecodingTask> AsyncAudioDecoder::DecodingTask::create(ArrayBuffer* audioData, float sampleRate, PassRefPtr<AudioBufferCallback> successCallback, PassRefPtr<AudioBufferCallback> errorCallback)
    9393{
    94     return adoptPtr(new DecodingTask(audioData, sampleRate, successCallback, errorCallback));
     94    return std::unique_ptr<DecodingTask>(new DecodingTask(audioData, sampleRate, successCallback, errorCallback));
    9595}
    9696

  • trunk/Source/WebCore/Modules/webaudio/AsyncAudioDecoder.h

    r153728 r156972  
    5858        WTF_MAKE_NONCOPYABLE(DecodingTask);
    5959    public:
    60         static PassOwnPtr<DecodingTask> create(JSC::ArrayBuffer* audioData, float sampleRate, PassRefPtr<AudioBufferCallback> successCallback, PassRefPtr<AudioBufferCallback> errorCallback);
     60        static std::unique_ptr<DecodingTask> create(JSC::ArrayBuffer* audioData, float sampleRate, PassRefPtr<AudioBufferCallback> successCallback, PassRefPtr<AudioBufferCallback> errorCallback);
    6161
    6262        void decode();

  • trunk/Source/WebCore/Modules/webdatabase/Database.cpp

    r147796 r156972  
    152152    }
    153153
    154     OwnPtr<DatabaseCloseTask> task = DatabaseCloseTask::create(this, &synchronizer);
    155     databaseContext()->databaseThread()->scheduleImmediateTask(task.release());
     154    auto task = DatabaseCloseTask::create(this, &synchronizer);
     155    databaseContext()->databaseThread()->scheduleImmediateTask(std::move(task));
    156156    synchronizer.waitForTaskCompletion();
    157157}
    … …  
    268268        return result;
    269269
    270     OwnPtr<DatabaseTableNamesTask> task = DatabaseTableNamesTask::create(this, &synchronizer, result);
    271     databaseContext()->databaseThread()->scheduleImmediateTask(task.release());
     270    auto task = DatabaseTableNamesTask::create(this, &synchronizer, result);
     271    databaseContext()->databaseThread()->scheduleImmediateTask(std::move(task));
    272272    synchronizer.waitForTaskCompletion();
    273273

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp

    r155414 r156972  
    5757
    5858    bool success = false;
    59     OwnPtr<DatabaseOpenTask> task = DatabaseOpenTask::create(this, setVersionInNewDatabase, &synchronizer, error, errorMessage, success);
    60     databaseContext()->databaseThread()->scheduleImmediateTask(task.release());
     59    auto task = DatabaseOpenTask::create(this, setVersionInNewDatabase, &synchronizer, error, errorMessage, success);
     60    databaseContext()->databaseThread()->scheduleImmediateTask(std::move(task));
    6161    synchronizer.waitForTaskCompletion();
    6262
    … …  
    145145
    146146    if (transaction && databaseContext()->databaseThread()) {
    147         OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
     147        auto task = DatabaseTransactionTask::create(transaction);
    148148        LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
    149149        m_transactionInProgress = true;
    150         databaseContext()->databaseThread()->scheduleTask(task.release());
     150        databaseContext()->databaseThread()->scheduleTask(std::move(task));
    151151    } else
    152152        m_transactionInProgress = false;
    … …  
    158158        return;
    159159
    160     OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
     160    auto task = DatabaseTransactionTask::create(transaction);
    161161    LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
    162     databaseContext()->databaseThread()->scheduleTask(task.release());
     162    databaseContext()->databaseThread()->scheduleTask(std::move(task));
    163163}
    164164

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.h

    r143551 r156972  
    101101class DatabaseBackend::DatabaseOpenTask : public DatabaseTask {
    102102public:
    103     static PassOwnPtr<DatabaseOpenTask> create(DatabaseBackend* db, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
     103    static std::unique_ptr<DatabaseOpenTask> create(DatabaseBackend* db, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
    104104    {
    105         return adoptPtr(new DatabaseOpenTask(db, setVersionInNewDatabase, synchronizer, error, errorMessage, success));
     105        return std::unique_ptr<DatabaseOpenTask>(new DatabaseOpenTask(db, setVersionInNewDatabase, synchronizer, error, errorMessage, success));
    106106    }
    107107
    … …  
    122122class DatabaseBackend::DatabaseCloseTask : public DatabaseTask {
    123123public:
    124     static PassOwnPtr<DatabaseCloseTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer)
     124    static std::unique_ptr<DatabaseCloseTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer)
    125125    {
    126         return adoptPtr(new DatabaseCloseTask(db, synchronizer));
     126        return std::unique_ptr<DatabaseCloseTask>(new DatabaseCloseTask(db, synchronizer));
    127127    }
    128128
    … …  
    141141
    142142    // Transaction task is never synchronous, so no 'synchronizer' parameter.
    143     static PassOwnPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransactionBackend> transaction)
     143    static std::unique_ptr<DatabaseTransactionTask> create(PassRefPtr<SQLTransactionBackend> transaction)
    144144    {
    145         return adoptPtr(new DatabaseTransactionTask(transaction));
     145        return std::unique_ptr<DatabaseTransactionTask>(new DatabaseTransactionTask(transaction));
    146146    }
    147147
    … …  
    162162class DatabaseBackend::DatabaseTableNamesTask : public DatabaseTask {
    163163public:
    164     static PassOwnPtr<DatabaseTableNamesTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
     164    static std::unique_ptr<DatabaseTableNamesTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
    165165    {
    166         return adoptPtr(new DatabaseTableNamesTask(db, synchronizer, names));
     166        return std::unique_ptr<DatabaseTableNamesTask>(new DatabaseTableNamesTask(db, synchronizer, names));
    167167    }
    168168

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseThread.cpp

    r155900 r156972  
    107107    }
    108108
    109     while (OwnPtr<DatabaseTask> task = m_queue.waitForMessage()) {
     109    while (auto task = m_queue.waitForMessage()) {
    110110        AutodrainedPool pool;
    111111
    … …  
    157157}
    158158
    159 void DatabaseThread::scheduleTask(PassOwnPtr<DatabaseTask> task)
     159void DatabaseThread::scheduleTask(std::unique_ptr<DatabaseTask> task)
    160160{
    161161    ASSERT(!task->hasSynchronizer() || task->hasCheckedForTermination());
    162     m_queue.append(task);
     162    m_queue.append(std::move(task));
    163163}
    164164
    165 void DatabaseThread::scheduleImmediateTask(PassOwnPtr<DatabaseTask> task)
     165void DatabaseThread::scheduleImmediateTask(std::unique_ptr<DatabaseTask> task)
    166166{
    167167    ASSERT(!task->hasSynchronizer() || task->hasCheckedForTermination());
    168     m_queue.prepend(task);
     168    m_queue.prepend(std::move(task));
    169169}
    170170
    … …  
    172172public:
    173173    SameDatabasePredicate(const DatabaseBackend* database) : m_database(database) { }
    174     bool operator()(const OwnPtr<DatabaseTask>& task) const { return task->database() == m_database; }
     174    bool operator()(const DatabaseTask& task) const { return task.database() == m_database; }
    175175private:
    176176    const DatabaseBackend* m_database;

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseThread.h

    r143551 r156972  
    5959    bool terminationRequested(DatabaseTaskSynchronizer* taskSynchronizer = 0) const;
    6060
    61     void scheduleTask(PassOwnPtr<DatabaseTask>);
    62     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.
     61    void scheduleTask(std::unique_ptr<DatabaseTask>);
     62    void scheduleImmediateTask(std::unique_ptr<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.
    6363    void unscheduleDatabaseTasks(DatabaseBackend*);
    6464

  • trunk/Source/WebCore/dom/default/PlatformMessagePortChannel.cpp

    r146151 r156972  
    3838namespace WebCore {
    3939
    40 PassOwnPtr<PlatformMessagePortChannel::EventData> PlatformMessagePortChannel::EventData::create(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels)
     40std::unique_ptr<PlatformMessagePortChannel::EventData> PlatformMessagePortChannel::EventData::create(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels)
    4141{
    42     return adoptPtr(new EventData(message, channels));
     42    return std::unique_ptr<EventData>(new EventData(message, channels));
    4343}
    4444
    … …  
    105105{
    106106    MutexLocker lock(m_channel->m_mutex);
    107     OwnPtr<PlatformMessagePortChannel::EventData> result = m_channel->m_incomingQueue->tryGetMessage();
     107    auto result = m_channel->m_incomingQueue->tryGetMessage();
    108108    if (!result)
    109109        return false;

  • trunk/Source/WebCore/dom/default/PlatformMessagePortChannel.h

    r155900 r156972  
    5050            WTF_MAKE_NONCOPYABLE(EventData); WTF_MAKE_FAST_ALLOCATED;
    5151        public:
    52             static PassOwnPtr<EventData> create(PassRefPtr<SerializedScriptValue>, PassOwnPtr<MessagePortChannelArray>);
     52            static std::unique_ptr<EventData> create(PassRefPtr<SerializedScriptValue>, PassOwnPtr<MessagePortChannelArray>);
    5353
    5454            PassRefPtr<SerializedScriptValue> message() { return m_message; }
    … …  
    6666            static PassRefPtr<MessagePortQueue> create() { return adoptRef(new MessagePortQueue()); }
    6767
    68             OwnPtr<PlatformMessagePortChannel::EventData> tryGetMessage()
     68            std::unique_ptr<PlatformMessagePortChannel::EventData> tryGetMessage()
    6969            {
    7070                return m_queue.tryGetMessage();
    7171            }
    7272
    73             bool appendAndCheckEmpty(PassOwnPtr<PlatformMessagePortChannel::EventData> message)
     73            bool appendAndCheckEmpty(std::unique_ptr<PlatformMessagePortChannel::EventData> message)
    7474            {
    75                 return m_queue.appendAndCheckEmpty(message);
     75                return m_queue.appendAndCheckEmpty(std::move(message));
    7676            }
    7777

  • trunk/Source/WebCore/fileapi/FileThread.cpp

    r155900 r156972  
    6565}
    6666
    67 void FileThread::postTask(PassOwnPtr<Task> task)
     67void FileThread::postTask(std::unique_ptr<Task> task)
    6868{
    69     m_queue.append(task);
     69    m_queue.append(std::move(task));
    7070}
    7171
    … …  
    7373public:
    7474    SameInstancePredicate(const void* instance) : m_instance(instance) { }
    75     bool operator()(const OwnPtr<FileThread::Task>& task) const { return task->instance() == m_instance; }
     75    bool operator()(FileThread::Task& task) const { return task.instance() == m_instance; }
    7676private:
    7777    const void* m_instance;
    … …  
    9999    }
    100100
    101     while (OwnPtr<Task> task = m_queue.waitForMessage()) {
     101    while (auto task = m_queue.waitForMessage()) {
    102102        AutodrainedPool pool;
    103103

  • trunk/Source/WebCore/fileapi/FileThread.h

    r110231 r156972  
    6666    };
    6767
    68     void postTask(PassOwnPtr<Task> task);
     68    void postTask(std::unique_ptr<Task>);
    6969
    7070    void unscheduleTasks(const void* instance);

  • trunk/Source/WebCore/fileapi/FileThreadTask.h

    r95901 r156972  
    4646    typedef FileThreadTask0<T> FileThreadTaskImpl;
    4747
    48     static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method)
    49     {
    50         return adoptPtr(new FileThreadTaskImpl(instance, method));
    51     }
    52 
    53 private:
    5448    FileThreadTask0(T* instance, Method method)
    5549        : FileThread::Task(instance)
    … …  
    5852    }
    5953
     54private:
    6055    virtual void performTask()
    6156    {
    … …  
    7469    typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
    7570
    76     static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method, Param1 parameter1)
    77     {
    78         return adoptPtr(new FileThreadTaskImpl(instance, method, parameter1));
    79     }
    80 
    81 private:
    8271    FileThreadTask1(T* instance, Method method, Param1 parameter1)
    8372        : FileThread::Task(instance)
    … …  
    8776    }
    8877
     78private:
    8979    virtual void performTask()
    9080    {
    … …  
    10595    typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
    10696
    107     static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2)
    108     {
    109         return adoptPtr(new FileThreadTaskImpl(instance, method, parameter1, parameter2));
    110     }
    111 
    112 private:
    11397    FileThreadTask2(T* instance, Method method, Param1 parameter1, Param2 parameter2)
    11498        : FileThread::Task(instance)
    … …  
    119103    }
    120104
     105private:
    121106    virtual void performTask()
    122107    {
    … …  
    139124    typedef typename CrossThreadTaskTraits<P3>::ParamType Param3;
    140125
    141     static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
    142     {
    143         return adoptPtr(new FileThreadTaskImpl(instance, method, parameter1, parameter2, parameter3));
    144     }
    145 
    146 private:
    147126    FileThreadTask3(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
    148127        : FileThread::Task(instance)
    … …  
    154133    }
    155134
     135private:
    156136    virtual void performTask()
    157137    {
    … …  
    167147
    168148template<typename T>
    169 PassOwnPtr<FileThread::Task> createFileThreadTask(
     149std::unique_ptr<FileThread::Task> createFileThreadTask(
    170150    T* const callee,
    171151    void (T::*method)());
    172152
    173153template<typename T>
    174 PassOwnPtr<FileThread::Task> createFileThreadTask(
     154std::unique_ptr<FileThread::Task> createFileThreadTask(
    175155    T* const callee,
    176156    void (T::*method)())
    177157{
    178     return FileThreadTask0<T>::create(
     158    return std::make_unique<FileThreadTask0<T>>(
    179159        callee,
    180160        method);
    … …  
    182162
    183163template<typename T, typename P1, typename MP1>
    184 PassOwnPtr<FileThread::Task> createFileThreadTask(
     164std::unique_ptr<FileThread::Task> createFileThreadTask(
    185165    T* const callee,
    186166    void (T::*method)(MP1),
    187167    const P1& parameter1)
    188168{
    189     return FileThreadTask1<T, typename CrossThreadCopier<P1>::Type, MP1>::create(
     169    return std::make_unique<FileThreadTask1<T, typename CrossThreadCopier<P1>::Type, MP1>>(
    190170        callee,
    191171        method,
    … …  
    194174
    195175template<typename T, typename P1, typename MP1, typename P2, typename MP2>
    196 PassOwnPtr<FileThread::Task> createFileThreadTask(
     176std::unique_ptr<FileThread::Task> createFileThreadTask(
    197177    T* const callee,
    198178    void (T::*method)(MP1, MP2),
    … …  
    200180    const P2& parameter2)
    201181{
    202     return FileThreadTask2<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>::create(
     182    return std::make_unique<FileThreadTask2<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>>(
    203183        callee,
    204184        method,
    … …  
    208188
    209189template<typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
    210 PassOwnPtr<FileThread::Task> createFileThreadTask(
     190std::unique_ptr<FileThread::Task> createFileThreadTask(
    211191    T* const callee,
    212192    void (T::*method)(MP1, MP2, MP3),
    … …  
    215195    const P3& parameter3)
    216196{
    217     return FileThreadTask3<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>::create(
     197    return std::make_unique<FileThreadTask3<T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>>(
    218198        callee,
    219199        method,

  • trunk/Source/WebCore/storage/StorageThread.cpp

    r149297 r156972  
    7676    ASSERT(!isMainThread());
    7777
    78     while (OwnPtr<Function<void ()> > function = m_queue.waitForMessage()) {
     78    while (auto function = m_queue.waitForMessage()) {
    7979        AutodrainedPool pool;
    8080        (*function)();
    … …  
    8686    ASSERT(isMainThread());
    8787    ASSERT(!m_queue.killed() && m_threadID);
    88     m_queue.append(adoptPtr(new Function<void ()>(function)));
     88    m_queue.append(std::make_unique<Function<void ()>>(function));
    8989}
    9090
    … …  
    9898        return;
    9999
    100     m_queue.append(adoptPtr(new Function<void ()>((bind(&StorageThread::performTerminate, this)))));
     100    m_queue.append(std::make_unique<Function<void ()>>(bind(&StorageThread::performTerminate, this)));
    101101    waitForThreadCompletion(m_threadID);
    102102    ASSERT(m_queue.killed());

  • trunk/Source/WebCore/workers/WorkerRunLoop.cpp

    r155900 r156972  
    7979    }
    8080
    81     bool operator()(const OwnPtr<WorkerRunLoop::Task>& task) const
    82     {
    83         return m_defaultMode || m_mode == task->mode();
     81    bool operator()(const WorkerRunLoop::Task& task) const
     82    {
     83        return m_defaultMode || m_mode == task.mode();
    8484    }
    8585
    … …  
    156156        absoluteTime = (predicate.isDefaultMode() && m_sharedTimer->isActive()) ? m_sharedTimer->fireTime() : MessageQueue<Task>::infiniteTime();
    157157    MessageQueueWaitResult result;
    158     OwnPtr<WorkerRunLoop::Task> task = m_messageQueue.waitForMessageFilteredWithTimeout(result, predicate, absoluteTime);
     158    auto task = m_messageQueue.waitForMessageFilteredWithTimeout(result, predicate, absoluteTime);
    159159
    160160    // If the context is closing, don't execute any further JavaScript tasks (per section 4.1.1 of the Web Workers spec).  However, there may be implementation cleanup tasks in the queue, so keep running through it.
    … …  
    185185
    186186    while (true) {
    187         OwnPtr<WorkerRunLoop::Task> task = m_messageQueue.tryGetMessageIgnoringKilled();
     187        auto task = m_messageQueue.tryGetMessageIgnoringKilled();
    188188        if (!task)
    189189            return;
    … …  
    212212}
    213213
    214 PassOwnPtr<WorkerRunLoop::Task> WorkerRunLoop::Task::create(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
    215 {
    216     return adoptPtr(new Task(task, mode));
     214std::unique_ptr<WorkerRunLoop::Task> WorkerRunLoop::Task::create(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
     215{
     216    return std::unique_ptr<Task>(new Task(task, mode));
    217217}
    218218

  • trunk/Source/WebCore/workers/WorkerRunLoop.h

    r152080 r156972  
    7272            WTF_MAKE_NONCOPYABLE(Task); WTF_MAKE_FAST_ALLOCATED;
    7373        public:
    74             static PassOwnPtr<Task> create(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode);
     74            static std::unique_ptr<Task> create(PassOwnPtr<ScriptExecutionContext::Task>, const String& mode);
    7575            ~Task() { }
    7676            const String& mode() const { return m_mode; }
Note: See TracChangeset for help on using the changeset viewer.