⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 201602 in webkit


Ignore:
Timestamp:
Jun 2, 2016, 10:59:56 AM (10 years ago)
Author:
Chris Dumez
Message:

Modernize various lambda captures
​https://bugs.webkit.org/show_bug.cgi?id=158292

Reviewed by Brady Eidson.

Modernize various lambda captures, especially the ones unnecessarily
allocating objects on the heap and destroying them in the lambda.

Source/WebCore:

  • Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp:

(WebCore::ThreadableWebSocketChannelClientWrapper::didConnect):
(WebCore::ThreadableWebSocketChannelClientWrapper::didReceiveMessage):
(WebCore::ThreadableWebSocketChannelClientWrapper::didReceiveBinaryData):
(WebCore::ThreadableWebSocketChannelClientWrapper::didUpdateBufferedAmount):
(WebCore::ThreadableWebSocketChannelClientWrapper::didStartClosingHandshake):
(WebCore::ThreadableWebSocketChannelClientWrapper::didClose):
(WebCore::ThreadableWebSocketChannelClientWrapper::didReceiveMessageError):
(WebCore::ThreadableWebSocketChannelClientWrapper::processPendingTasks):
(WebCore::ThreadableWebSocketChannelClientWrapper::resume): Deleted.

  • Modules/websockets/WorkerThreadableWebSocketChannel.cpp:

(WebCore::WorkerThreadableWebSocketChannel::Bridge::disconnect):

  • bindings/js/JSCallbackData.h:

(WebCore::DeleteCallbackDataTask::DeleteCallbackDataTask):

  • loader/WorkerThreadableLoader.cpp:

(WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):
(WebCore::WorkerThreadableLoader::MainThreadBridge::destroy):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didSendData):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveResponse):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveData):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didFinishLoading):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didFail):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didFailAccessControlCheck):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didFailRedirectCheck):
(WebCore::WorkerThreadableLoader::MainThreadBridge::cancel): Deleted.

Source/WebKit2:

  • NetworkProcess/NetworkProcess.cpp:

(WebKit::fetchDiskCacheEntries):
(WebKit::clearDiskCacheEntries):
(WebKit::NetworkProcess::fetchWebsiteData): Deleted.

  • NetworkProcess/cache/NetworkCache.cpp:

(WebKit::NetworkCache::Cache::traverse):

  • NetworkProcess/cache/NetworkCache.h:
  • NetworkProcess/cache/NetworkCacheStorage.cpp:

(WebKit::NetworkCache::Storage::TraverseOperation::TraverseOperation):

  • NetworkProcess/cache/NetworkCacheStorage.h:
Location:
trunk/Source
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r201601 r201602  
     12016-06-02  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize various lambda captures
     4        https://bugs.webkit.org/show_bug.cgi?id=158292
     5
     6        Reviewed by Brady Eidson.
     7
     8        Modernize various lambda captures, especially the ones unnecessarily
     9        allocating objects on the heap and destroying them in the lambda.
     10
     11        * Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp:
     12        (WebCore::ThreadableWebSocketChannelClientWrapper::didConnect):
     13        (WebCore::ThreadableWebSocketChannelClientWrapper::didReceiveMessage):
     14        (WebCore::ThreadableWebSocketChannelClientWrapper::didReceiveBinaryData):
     15        (WebCore::ThreadableWebSocketChannelClientWrapper::didUpdateBufferedAmount):
     16        (WebCore::ThreadableWebSocketChannelClientWrapper::didStartClosingHandshake):
     17        (WebCore::ThreadableWebSocketChannelClientWrapper::didClose):
     18        (WebCore::ThreadableWebSocketChannelClientWrapper::didReceiveMessageError):
     19        (WebCore::ThreadableWebSocketChannelClientWrapper::processPendingTasks):
     20        (WebCore::ThreadableWebSocketChannelClientWrapper::resume): Deleted.
     21        * Modules/websockets/WorkerThreadableWebSocketChannel.cpp:
     22        (WebCore::WorkerThreadableWebSocketChannel::Bridge::disconnect):
     23        * bindings/js/JSCallbackData.h:
     24        (WebCore::DeleteCallbackDataTask::DeleteCallbackDataTask):
     25        * loader/WorkerThreadableLoader.cpp:
     26        (WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):
     27        (WebCore::WorkerThreadableLoader::MainThreadBridge::destroy):
     28        (WebCore::WorkerThreadableLoader::MainThreadBridge::didSendData):
     29        (WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveResponse):
     30        (WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveData):
     31        (WebCore::WorkerThreadableLoader::MainThreadBridge::didFinishLoading):
     32        (WebCore::WorkerThreadableLoader::MainThreadBridge::didFail):
     33        (WebCore::WorkerThreadableLoader::MainThreadBridge::didFailAccessControlCheck):
     34        (WebCore::WorkerThreadableLoader::MainThreadBridge::didFailRedirectCheck):
     35        (WebCore::WorkerThreadableLoader::MainThreadBridge::cancel): Deleted.
     36
    1372016-06-02  Adam Bergkvist  <adam.bergkvist@ericsson.com>
    238

  • trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp

    r198869 r201602  
    156156void ThreadableWebSocketChannelClientWrapper::didConnect()
    157157{
    158     ref();
    159     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this] (ScriptExecutionContext&) {
     158    m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext&) {
    160159        if (m_client)
    161160            m_client->didConnect();
    162         deref();
    163161    }));
    164162
    … …  
    169167void ThreadableWebSocketChannelClientWrapper::didReceiveMessage(const String& message)
    170168{
    171     ref();
    172     String messageCopy = message.isolatedCopy();
    173     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, message] (ScriptExecutionContext&) {
     169    m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this), message = message.isolatedCopy()] (ScriptExecutionContext&) {
    174170        if (m_client)
    175171            m_client->didReceiveMessage(message);
    176         deref();
    177172    }));
    178173
    … …  
    183178void ThreadableWebSocketChannelClientWrapper::didReceiveBinaryData(Vector<uint8_t>&& binaryData)
    184179{
    185     ref();
    186     Vector<uint8_t>* capturedData = new Vector<uint8_t>(WTFMove(binaryData));
    187     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, capturedData] (ScriptExecutionContext&) {
    188         if (m_client)
    189             m_client->didReceiveBinaryData(WTFMove(*capturedData));
    190         delete capturedData;
    191         deref();
     180    m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this), binaryData = WTFMove(binaryData)] (ScriptExecutionContext&) mutable {
     181        if (m_client)
     182            m_client->didReceiveBinaryData(WTFMove(binaryData));
    192183    }));
    193184
    … …  
    198189void ThreadableWebSocketChannelClientWrapper::didUpdateBufferedAmount(unsigned long bufferedAmount)
    199190{
    200     ref();
    201     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, bufferedAmount] (ScriptExecutionContext&) {
     191    m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this), bufferedAmount] (ScriptExecutionContext&) {
    202192        if (m_client)
    203193            m_client->didUpdateBufferedAmount(bufferedAmount);
    204         deref();
    205194    }));
    206195
    … …  
    211200void ThreadableWebSocketChannelClientWrapper::didStartClosingHandshake()
    212201{
    213     ref();
    214     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this] (ScriptExecutionContext&) {
     202    m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext&) {
    215203        if (m_client)
    216204            m_client->didStartClosingHandshake();
    217         deref();
    218205    }));
    219206
    … …  
    224211void ThreadableWebSocketChannelClientWrapper::didClose(unsigned long unhandledBufferedAmount, WebSocketChannelClient::ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
    225212{
    226     ref();
    227     String reasonCopy = reason.isolatedCopy();
    228     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>(
    229         [this, unhandledBufferedAmount, closingHandshakeCompletion, code, reasonCopy] (ScriptExecutionContext&) {
     213    m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this), unhandledBufferedAmount, closingHandshakeCompletion, code, reason = reason.isolatedCopy()] (ScriptExecutionContext&) {
    230214            if (m_client)
    231                 m_client->didClose(unhandledBufferedAmount, closingHandshakeCompletion, code, reasonCopy);
    232             deref();
     215                m_client->didClose(unhandledBufferedAmount, closingHandshakeCompletion, code, reason);
    233216        }));
    234217
    … …  
    239222void ThreadableWebSocketChannelClientWrapper::didReceiveMessageError()
    240223{
    241     ref();
    242     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this] (ScriptExecutionContext&) {
     224    m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext&) {
    243225        if (m_client)
    244226            m_client->didReceiveMessageError();
    245         deref();
    246227    }));
    247228
    … …  
    268249        // When a synchronous operation is in progress (i.e. the execution stack contains
    269250        // WorkerThreadableWebSocketChannel::waitForMethodCompletion()), we cannot invoke callbacks in this run loop.
    270         ref();
    271         m_context->postTask([this] (ScriptExecutionContext& context) {
     251        m_context->postTask([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext& context) {
    272252            ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    273253            processPendingTasks();
    274             deref();
    275254        });
    276255        return;

  • trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp

    r201543 r201602  
    545545    clearClientWrapper();
    546546    if (m_peer) {
    547         m_loaderProxy.postTaskToLoader([peer = m_peer] (ScriptExecutionContext& context) {
     547        m_loaderProxy.postTaskToLoader([peer = std::unique_ptr<Peer>(m_peer)] (ScriptExecutionContext& context) {
    548548            ASSERT(isMainThread());
    549549            ASSERT_UNUSED(context, context.isDocument());
    550             delete peer;
    551550        });
    552551        m_peer = nullptr;

  • trunk/Source/WebCore/bindings/js/JSCallbackData.h

    r190113 r201602  
    117117    template <typename CallbackDataType>
    118118    explicit DeleteCallbackDataTask(CallbackDataType* data)
    119         : ScriptExecutionContext::Task(ScriptExecutionContext::Task::CleanupTask, [data] (ScriptExecutionContext&) {
    120             delete data;
     119        : ScriptExecutionContext::Task(ScriptExecutionContext::Task::CleanupTask, [data = std::unique_ptr<CallbackDataType>(data)] (ScriptExecutionContext&) {
    121120        })
    122121    {

  • trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp

    r201594 r201602  
    118118
    119119    // "delete this" and m_mainThreadLoader::deref() on the worker object's thread.
    120     m_loaderProxy.postTaskToLoader([this] (ScriptExecutionContext& context) {
     120    m_loaderProxy.postTaskToLoader([self = std::unique_ptr<WorkerThreadableLoader::MainThreadBridge>(this)] (ScriptExecutionContext& context) {
    121121        ASSERT(isMainThread());
    122122        ASSERT_UNUSED(context, context.isDocument());
    123         delete this;
    124123    });
    125124}
    … …  
    155154void WorkerThreadableLoader::MainThreadBridge::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
    156155{
    157     RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    158     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, bytesSent, totalBytesToBeSent] (ScriptExecutionContext& context) {
    159         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    160         workerClientWrapper->didSendData(bytesSent, totalBytesToBeSent);
     156    Ref<ThreadableLoaderClientWrapper> protectedWorkerClientWrapper = *m_workerClientWrapper;
     157    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = WTFMove(protectedWorkerClientWrapper), bytesSent, totalBytesToBeSent] (ScriptExecutionContext& context) mutable {
     158        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     159        protectedWorkerClientWrapper->didSendData(bytesSent, totalBytesToBeSent);
    161160    }, m_taskMode);
    162161}
    … …  
    164163void WorkerThreadableLoader::MainThreadBridge::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
    165164{
    166     RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    167     auto* responseData = response.copyData().release();
    168     if (!m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, identifier, responseData] (ScriptExecutionContext& context) {
    169         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    170         auto response(ResourceResponse::adopt(std::unique_ptr<CrossThreadResourceResponseData>(responseData)));
    171         workerClientWrapper->didReceiveResponse(identifier, *response);
    172     }, m_taskMode))
    173         delete responseData;
     165    Ref<ThreadableLoaderClientWrapper> protectedWorkerClientWrapper = *m_workerClientWrapper;
     166    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = WTFMove(protectedWorkerClientWrapper), identifier, responseData = response.copyData()] (ScriptExecutionContext& context) mutable {
     167        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     168        auto response(ResourceResponse::adopt(WTFMove(responseData)));
     169        protectedWorkerClientWrapper->didReceiveResponse(identifier, *response);
     170    }, m_taskMode);
    174171}
    175172
    176173void WorkerThreadableLoader::MainThreadBridge::didReceiveData(const char* data, int dataLength)
    177174{
    178     RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    179     Vector<char>* vectorPtr = new Vector<char>(dataLength);
    180     memcpy(vectorPtr->data(), data, dataLength);
    181     if (!m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, vectorPtr] (ScriptExecutionContext& context) {
    182         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    183         workerClientWrapper->didReceiveData(vectorPtr->data(), vectorPtr->size());
    184         delete vectorPtr;
    185     }, m_taskMode))
    186         delete vectorPtr;
     175    Ref<ThreadableLoaderClientWrapper> protectedWorkerClientWrapper = *m_workerClientWrapper;
     176    Vector<char> vector(dataLength);
     177    memcpy(vector.data(), data, dataLength);
     178    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = WTFMove(protectedWorkerClientWrapper), vector = WTFMove(vector)] (ScriptExecutionContext& context) mutable {
     179        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     180        protectedWorkerClientWrapper->didReceiveData(vector.data(), vector.size());
     181    }, m_taskMode);
    187182}
    188183
    … …  
    190185{
    191186    m_loadingFinished = true;
    192     RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    193     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, identifier, finishTime] (ScriptExecutionContext& context) {
    194         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    195         workerClientWrapper->didFinishLoading(identifier, finishTime);
     187    Ref<ThreadableLoaderClientWrapper> protectedWorkerClientWrapper = *m_workerClientWrapper;
     188    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = WTFMove(protectedWorkerClientWrapper), identifier, finishTime] (ScriptExecutionContext& context) mutable {
     189        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     190        protectedWorkerClientWrapper->didFinishLoading(identifier, finishTime);
    196191    }, m_taskMode);
    197192}
    … …  
    200195{
    201196    m_loadingFinished = true;
    202     RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    203     ResourceError* capturedError = new ResourceError(error.copy());
    204     if (!m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, capturedError] (ScriptExecutionContext& context) {
    205         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    206         workerClientWrapper->didFail(*capturedError);
    207         delete capturedError;
    208     }, m_taskMode))
    209         delete capturedError;
     197    Ref<ThreadableLoaderClientWrapper> protectedWorkerClientWrapper = *m_workerClientWrapper;
     198    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = WTFMove(protectedWorkerClientWrapper), error = error.copy()] (ScriptExecutionContext& context) mutable {
     199        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     200        protectedWorkerClientWrapper->didFail(error);
     201    }, m_taskMode);
    210202}
    211203
    … …  
    213205{
    214206    m_loadingFinished = true;
    215     RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    216     ResourceError* capturedError = new ResourceError(error.copy());
    217     if (!m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, capturedError] (ScriptExecutionContext& context) {
    218         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    219         workerClientWrapper->didFailAccessControlCheck(*capturedError);
    220         delete capturedError;
    221     }, m_taskMode))
    222         delete capturedError;
     207    Ref<ThreadableLoaderClientWrapper> protectedWorkerClientWrapper = *m_workerClientWrapper;
     208    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = WTFMove(protectedWorkerClientWrapper), error = error.copy()] (ScriptExecutionContext& context) mutable {
     209        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     210        protectedWorkerClientWrapper->didFailAccessControlCheck(error);
     211    }, m_taskMode);
    223212}
    224213
    … …  
    226215{
    227216    m_loadingFinished = true;
    228     RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    229     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper] (ScriptExecutionContext& context) {
    230         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    231         workerClientWrapper->didFailRedirectCheck();
     217    Ref<ThreadableLoaderClientWrapper> protectedWorkerClientWrapper = *m_workerClientWrapper;
     218    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = WTFMove(protectedWorkerClientWrapper)] (ScriptExecutionContext& context) mutable {
     219        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     220        protectedWorkerClientWrapper->didFailRedirectCheck();
    232221    }, m_taskMode);
    233222}

  • trunk/Source/WebKit2/ChangeLog

    r201600 r201602  
     12016-06-02  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize various lambda captures
     4        https://bugs.webkit.org/show_bug.cgi?id=158292
     5
     6        Reviewed by Brady Eidson.
     7
     8        Modernize various lambda captures, especially the ones unnecessarily
     9        allocating objects on the heap and destroying them in the lambda.
     10
     11        * NetworkProcess/NetworkProcess.cpp:
     12        (WebKit::fetchDiskCacheEntries):
     13        (WebKit::clearDiskCacheEntries):
     14        (WebKit::NetworkProcess::fetchWebsiteData): Deleted.
     15        * NetworkProcess/cache/NetworkCache.cpp:
     16        (WebKit::NetworkCache::Cache::traverse):
     17        * NetworkProcess/cache/NetworkCache.h:
     18        * NetworkProcess/cache/NetworkCacheStorage.cpp:
     19        (WebKit::NetworkCache::Storage::TraverseOperation::TraverseOperation):
     20        * NetworkProcess/cache/NetworkCacheStorage.h:
     21
    1222016-06-02  Chris Dumez  <cdumez@apple.com>
    223

  • trunk/Source/WebKit2/NetworkProcess/NetworkProcess.cpp

    r201575 r201602  
    309309}
    310310
    311 static void fetchDiskCacheEntries(SessionID sessionID, OptionSet<WebsiteDataFetchOption> fetchOptions, std::function<void (Vector<WebsiteData::Entry>)> completionHandler)
     311static void fetchDiskCacheEntries(SessionID sessionID, OptionSet<WebsiteDataFetchOption> fetchOptions, NoncopyableFunction<void (Vector<WebsiteData::Entry>)>&& completionHandler)
    312312{
    313313#if ENABLE(NETWORK_CACHE)
    314314    if (NetworkCache::singleton().isEnabled()) {
    315         auto* originsAndSizes = new HashMap<RefPtr<SecurityOrigin>, uint64_t>();
    316 
    317         NetworkCache::singleton().traverse([fetchOptions, completionHandler, originsAndSizes](auto* traversalEntry) {
     315        HashMap<RefPtr<SecurityOrigin>, uint64_t> originsAndSizes;
     316        NetworkCache::singleton().traverse([fetchOptions, completionHandler = WTFMove(completionHandler), originsAndSizes = WTFMove(originsAndSizes)](auto* traversalEntry) mutable {
    318317            if (!traversalEntry) {
    319318                Vector<WebsiteData::Entry> entries;
    320319
    321                 for (auto& originAndSize : *originsAndSizes) {
    322                     WebsiteData::Entry entry { originAndSize.key, WebsiteDataType::DiskCache, originAndSize.value };
    323 
    324                     entries.append(WTFMove(entry));
    325                 }
    326 
    327                 delete originsAndSizes;
    328 
    329                 RunLoop::main().dispatch([completionHandler, entries = WTFMove(entries)] {
     320                for (auto& originAndSize : originsAndSizes)
     321                    entries.append(WebsiteData::Entry { originAndSize.key, WebsiteDataType::DiskCache, originAndSize.value });
     322
     323                RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), entries = WTFMove(entries)] {
    330324                    completionHandler(entries);
    331325                });
    … …  
    334328            }
    335329
    336             auto result = originsAndSizes->add(SecurityOrigin::create(traversalEntry->entry.response().url()), 0);
     330            auto result = originsAndSizes.add(SecurityOrigin::create(traversalEntry->entry.response().url()), 0);
    337331
    338332            if (fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes))
    … …  
    351345#endif
    352346
    353     RunLoop::main().dispatch([completionHandler, entries = WTFMove(entries)] {
     347    RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), entries = WTFMove(entries)] {
    354348        completionHandler(entries);
    355349    });
    … …  
    359353{
    360354    struct CallbackAggregator final : public RefCounted<CallbackAggregator> {
    361         explicit CallbackAggregator(std::function<void (WebsiteData)> completionHandler)
     355        explicit CallbackAggregator(NoncopyableFunction<void (WebsiteData)>&& completionHandler)
    362356            : m_completionHandler(WTFMove(completionHandler))
    363357        {
    … …  
    373367        }
    374368
    375         std::function<void (WebsiteData)> m_completionHandler;
     369        NoncopyableFunction<void (WebsiteData)> m_completionHandler;
    376370        WebsiteData m_websiteData;
    377371    };
    378372
    379     RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator([this, callbackID] (WebsiteData websiteData) {
     373    auto callbackAggregator = adoptRef(*new CallbackAggregator([this, callbackID] (WebsiteData websiteData) {
    380374        parentProcessConnection()->send(Messages::NetworkProcessProxy::DidFetchWebsiteData(callbackID, websiteData), 0);
    381375    }));
    … …  
    387381
    388382    if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
    389         fetchDiskCacheEntries(sessionID, fetchOptions, [callbackAggregator](auto entries) {
     383        fetchDiskCacheEntries(sessionID, fetchOptions, [callbackAggregator = WTFMove(callbackAggregator)](auto entries) mutable {
    390384            callbackAggregator->m_websiteData.entries.appendVector(entries);
    391385        });
    … …  
    419413}
    420414
    421 static void clearDiskCacheEntries(const Vector<SecurityOriginData>& origins, std::function<void ()>&& completionHandler)
     415static void clearDiskCacheEntries(const Vector<SecurityOriginData>& origins, NoncopyableFunction<void ()>&& completionHandler)
    422416{
    423417#if ENABLE(NETWORK_CACHE)
    424418    if (NetworkCache::singleton().isEnabled()) {
    425         auto* originsToDelete = new HashSet<RefPtr<SecurityOrigin>>();
    426 
     419        HashSet<RefPtr<SecurityOrigin>> originsToDelete;
    427420        for (auto& origin : origins)
    428             originsToDelete->add(origin.securityOrigin());
    429 
    430         auto* cacheKeysToDelete = new Vector<NetworkCache::Key>;
    431 
    432         NetworkCache::singleton().traverse([completionHandler = WTFMove(completionHandler), originsToDelete, cacheKeysToDelete](auto* traversalEntry) mutable {
     421            originsToDelete.add(origin.securityOrigin());
     422
     423        Vector<NetworkCache::Key> cacheKeysToDelete;
     424        NetworkCache::singleton().traverse([completionHandler = WTFMove(completionHandler), originsToDelete = WTFMove(originsToDelete), cacheKeysToDelete = WTFMove(cacheKeysToDelete)](auto* traversalEntry) mutable {
    433425            if (traversalEntry) {
    434                 if (originsToDelete->contains(SecurityOrigin::create(traversalEntry->entry.response().url())))
    435                     cacheKeysToDelete->append(traversalEntry->entry.key());
     426                if (originsToDelete.contains(SecurityOrigin::create(traversalEntry->entry.response().url())))
     427                    cacheKeysToDelete.append(traversalEntry->entry.key());
    436428                return;
    437429            }
    438430
    439             delete originsToDelete;
    440 
    441             for (auto& key : *cacheKeysToDelete)
     431            for (auto& key : cacheKeysToDelete)
    442432                NetworkCache::singleton().remove(key);
    443 
    444             delete cacheKeysToDelete;
    445433
    446434            RunLoop::main().dispatch(WTFMove(completionHandler));

  • trunk/Source/WebKit2/NetworkProcess/NetworkProcess.h

    r199230 r201602  
    3737#include <wtf/Forward.h>
    3838#include <wtf/NeverDestroyed.h>
     39#include <wtf/NoncopyableFunction.h>
    3940#include <wtf/RetainPtr.h>
    4041

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp

    r201600 r201602  
    522522}
    523523
    524 void Cache::traverse(std::function<void (const TraversalEntry*)>&& traverseHandler)
     524void Cache::traverse(NoncopyableFunction<void (const TraversalEntry*)>&& traverseHandler)
    525525{
    526526    ASSERT(isEnabled());

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.h

    r201484 r201602  
    3333#include "ShareableResource.h"
    3434#include <WebCore/ResourceResponse.h>
     35#include <wtf/NoncopyableFunction.h>
    3536#include <wtf/text/WTFString.h>
    3637
    … …  
    114115        const Storage::RecordInfo& recordInfo;
    115116    };
    116     void traverse(std::function<void (const TraversalEntry*)>&&);
     117    void traverse(NoncopyableFunction<void (const TraversalEntry*)>&&);
    117118    void remove(const Key&);
    118119    void remove(const WebCore::ResourceRequest&);

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStorage.cpp

    r201575 r201602  
    114114    WTF_MAKE_FAST_ALLOCATED;
    115115public:
    116     TraverseOperation(const String& type, TraverseFlags flags, const TraverseHandler& handler)
     116    TraverseOperation(const String& type, TraverseFlags flags, TraverseHandler&& handler)
    117117        : type(type)
    118118        , flags(flags)
    119         , handler(handler)
     119        , handler(WTFMove(handler))
    120120    { }
    121121

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStorage.h

    r200394 r201602  
    3636#include <wtf/Deque.h>
    3737#include <wtf/HashSet.h>
     38#include <wtf/NoncopyableFunction.h>
    3839#include <wtf/Optional.h>
    3940#include <wtf/WorkQueue.h>
    … …  
    7980    };
    8081    typedef unsigned TraverseFlags;
    81     typedef std::function<void (const Record*, const RecordInfo&)> TraverseHandler;
     82    typedef NoncopyableFunction<void (const Record*, const RecordInfo&)> TraverseHandler;
    8283    // Null record signals end.
    8384    void traverse(const String& type, TraverseFlags, TraverseHandler&&);
Note: See TracChangeset for help on using the changeset viewer.