Changeset 183755 in webkit


Ignore:
Timestamp:
May 4, 2015, 11:51:36 AM (10 years ago)
Author:
Antti Koivisto
Message:

Network Cache: Support time based cache clearing
​https://bugs.webkit.org/show_bug.cgi?id=144568
<rdar://problem/19769820>

Reviewed by Andreas Kling.

Support clearing cache entries newer than given time only.

  • NetworkProcess/cache/NetworkCache.cpp:

(WebKit::NetworkCache::Cache::deleteDumpFile):
(WebKit::NetworkCache::Storage::traverse):

Also fix thread safety of traverse handler function.

(WebKit::NetworkCache::Cache::clear):

Also add completion handler to support the API properly.

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

(WebKit::NetworkCache::Storage::clear):

  • NetworkProcess/cache/NetworkCacheStorage.h:
  • NetworkProcess/cocoa/NetworkProcessCocoa.mm:

(WebKit::clearNSURLCache):

Factor to a function.

(WebKit::NetworkProcess::clearDiskCache):

Location:
trunk/Source/WebKit2
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r183746 r183755  
     12015-05-04  Antti Koivisto  <antti@apple.com>
     2
     3        Network Cache: Support time based cache clearing
     4        https://bugs.webkit.org/show_bug.cgi?id=144568
     5        <rdar://problem/19769820>
     6
     7        Reviewed by Andreas Kling.
     8
     9        Support clearing cache entries newer than given time only.
     10
     11        * NetworkProcess/cache/NetworkCache.cpp:
     12        (WebKit::NetworkCache::Cache::deleteDumpFile):
     13        (WebKit::NetworkCache::Storage::traverse):
     14
     15            Also fix thread safety of traverse handler function.
     16
     17        (WebKit::NetworkCache::Cache::clear):
     18
     19            Also add completion handler to support the API properly.
     20
     21        * NetworkProcess/cache/NetworkCache.h:
     22        * NetworkProcess/cache/NetworkCacheStorage.cpp:
     23        (WebKit::NetworkCache::Storage::clear):
     24        * NetworkProcess/cache/NetworkCacheStorage.h:
     25        * NetworkProcess/cocoa/NetworkProcessCocoa.mm:
     26        (WebKit::clearNSURLCache):
     27
     28            Factor to a function.
     29
     30        (WebKit::NetworkProcess::clearDiskCache):
     31
    1322015-05-04  Zan Dobersek  <zdobersek@igalia.com>
    233

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

    r183730 r183755  
    4141#include <WebCore/SharedBuffer.h>
    4242#include <wtf/NeverDestroyed.h>
     43#include <wtf/RunLoop.h>
    4344#include <wtf/text/StringBuilder.h>
    4445
    … …  
    525526}
    526527
    527 void Cache::clear()
     528void Cache::deleteDumpFile()
     529{
     530    auto queue = WorkQueue::create("com.apple.WebKit.Cache.delete");
     531    StringCapture dumpFilePathCapture(dumpFilePath());
     532    queue->dispatch([dumpFilePathCapture] {
     533        WebCore::deleteFile(dumpFilePathCapture.string());
     534    });
     535}
     536
     537void Cache::clear(std::chrono::system_clock::time_point modifiedSince, std::function<void ()>&& completionHandler)
    528538{
    529539    LOG(NetworkCache, "(NetworkProcess) clearing cache");
    530     if (m_storage) {
    531         m_storage->clear();
    532 
    533         auto queue = WorkQueue::create("com.apple.WebKit.Cache.delete");
    534         StringCapture dumpFilePathCapture(dumpFilePath());
    535         queue->dispatch([dumpFilePathCapture] {
    536             WebCore::deleteFile(dumpFilePathCapture.string());
    537         });
    538     }
     540    deleteDumpFile();
     541
    539542    if (m_statistics)
    540543        m_statistics->clear();
     544
     545    if (!m_storage) {
     546        RunLoop::main().dispatch(completionHandler);
     547        return;
     548    }
     549    m_storage->clear(modifiedSince, WTF::move(completionHandler));
     550}
     551
     552void Cache::clear()
     553{
     554    clear(std::chrono::system_clock::time_point::min(), nullptr);
    541555}
    542556

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

    r183467 r183755  
    102102
    103103    void clear();
     104    void clear(std::chrono::system_clock::time_point modifiedSince, std::function<void ()>&& completionHandler);
    104105
    105106    void dumpContentsToFile();
    … …  
    112113
    113114    String dumpFilePath() const;
     115    void deleteDumpFile();
    114116
    115117    std::unique_ptr<Storage> m_storage;

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

    r183273 r183755  
    658658}
    659659
    660 void Storage::traverse(TraverseFlags flags, std::function<void (const Record*, const RecordInfo&)>&& traverseHandler)
    661 {
    662     ioQueue().dispatch([this, flags, traverseHandler] {
     660void Storage::traverse(TraverseFlags flags, TraverseHandler&& traverseHandler)
     661{
     662    ASSERT(RunLoop::isMain());
     663    ASSERT(traverseHandler);
     664    // Avoid non-thread safe std::function copies.
     665    auto* traverseHandlerPtr = new TraverseHandler(WTF::move(traverseHandler));
     666   
     667    ioQueue().dispatch([this, flags, traverseHandlerPtr] {
     668        auto& traverseHandler = *traverseHandlerPtr;
    663669        traverseCacheFiles(recordsPath(), [this, flags, &traverseHandler](const String& fileName, const String& partitionPath) {
    664670            if (fileName.length() != Key::hashStringLength())
    … …  
    685691            });
    686692        });
    687         RunLoop::main().dispatch([this, traverseHandler] {
    688             traverseHandler(nullptr, { });
     693        RunLoop::main().dispatch([this, traverseHandlerPtr] {
     694            (*traverseHandlerPtr)(nullptr, { });
     695            delete traverseHandlerPtr;
    689696        });
    690697    });
    … …  
    709716}
    710717
    711 void Storage::clear()
     718void Storage::clear(std::chrono::system_clock::time_point modifiedSinceTime, std::function<void ()>&& completionHandler)
    712719{
    713720    ASSERT(RunLoop::isMain());
    … …  
    720727    m_approximateRecordsSize = 0;
    721728
    722     ioQueue().dispatch([this] {
     729    // Avoid non-thread safe std::function copies.
     730    auto* completionHandlerPtr = completionHandler ? new std::function<void ()>(WTF::move(completionHandler)) : nullptr;
     731
     732    ioQueue().dispatch([this, modifiedSinceTime, completionHandlerPtr] {
    723733        auto recordsPath = this->recordsPath();
    724         traverseDirectory(recordsPath, DT_DIR, [&recordsPath](const String& subdirName) {
     734        traverseDirectory(recordsPath, DT_DIR, [&recordsPath, modifiedSinceTime](const String& subdirName) {
    725735            String subdirPath = WebCore::pathByAppendingComponent(recordsPath, subdirName);
    726             traverseDirectory(subdirPath, DT_REG, [&subdirPath](const String& fileName) {
    727                 WebCore::deleteFile(WebCore::pathByAppendingComponent(subdirPath, fileName));
     736            traverseDirectory(subdirPath, DT_REG, [&subdirPath, modifiedSinceTime](const String& fileName) {
     737                auto filePath = WebCore::pathByAppendingComponent(subdirPath, fileName);
     738                if (modifiedSinceTime > std::chrono::system_clock::time_point::min()) {
     739                    auto times = fileTimes(filePath);
     740                    if (times.modification < modifiedSinceTime)
     741                        return;
     742                }
     743                WebCore::deleteFile(filePath);
    728744            });
    729745            WebCore::deleteEmptyDirectory(subdirPath);
    … …  
    732748        // This cleans unreferences blobs.
    733749        m_blobStorage.synchronize();
     750
     751        if (completionHandlerPtr) {
     752            RunLoop::main().dispatch([completionHandlerPtr] {
     753                (*completionHandlerPtr)();
     754                delete completionHandlerPtr;
     755            });
     756        }
    734757    });
    735758}

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

    r183273 r183755  
    6363
    6464    void remove(const Key&);
     65    void clear(std::chrono::system_clock::time_point modifiedSinceTime, std::function<void ()>&& completionHandler);
    6566
    6667    struct RecordInfo {
    … …  
    7576    };
    7677    typedef unsigned TraverseFlags;
     78    typedef std::function<void (const Record*, const RecordInfo&)> TraverseHandler;
    7779    // Null record signals end.
    78     void traverse(TraverseFlags, std::function<void (const Record*, const RecordInfo&)>&&);
     80    void traverse(TraverseFlags, TraverseHandler&&);
    7981
    8082    void setCapacity(size_t);
    8183    size_t approximateSize() const;
    82     void clear();
    8384
    8485    static const unsigned version = 3;

  • trunk/Source/WebKit2/NetworkProcess/cocoa/NetworkProcessCocoa.mm

    r183737 r183755  
    156156}
    157157
    158 void NetworkProcess::clearDiskCache(std::chrono::system_clock::time_point modifiedSince, std::function<void ()> completionHandler)
     158static void clearNSURLCache(dispatch_group_t group, std::chrono::system_clock::time_point modifiedSince, const std::function<void ()>& completionHandler)
    159159{
    160 #if ENABLE(NETWORK_CACHE)
    161     NetworkCache::singleton().clear();
    162 #endif
    163 
    164     if (!m_clearCacheDispatchGroup)
    165         m_clearCacheDispatchGroup = dispatch_group_create();
    166 
    167     dispatch_group_async(m_clearCacheDispatchGroup, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), [modifiedSince, completionHandler] {
     160    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), [modifiedSince, completionHandler] {
    168161        NSURLCache *cache = [NSURLCache sharedURLCache];
    169162
    … …  
    181174}
    182175
     176void NetworkProcess::clearDiskCache(std::chrono::system_clock::time_point modifiedSince, std::function<void ()> completionHandler)
     177{
     178    if (!m_clearCacheDispatchGroup)
     179        m_clearCacheDispatchGroup = dispatch_group_create();
     180
     181#if ENABLE(NETWORK_CACHE)
     182    auto group = m_clearCacheDispatchGroup;
     183    dispatch_group_async(group, dispatch_get_main_queue(), [group, modifiedSince, completionHandler] {
     184        NetworkCache::singleton().clear(modifiedSince, [group, modifiedSince, completionHandler] {
     185            // FIXME: Probably not necessary.
     186            clearNSURLCache(group, modifiedSince, completionHandler);
     187        });
     188    });
     189#else
     190    clearNSURLCache(m_clearCacheDispatchGroup, modifiedSince, completionHandler);
     191#endif
     192}
     193
    183194}
    184195
Note: See TracChangeset for help on using the changeset viewer.