Changeset 199326 in webkit


Ignore:
Timestamp:
Apr 11, 2016 6:00:07 PM (8 years ago)
Author:
commit-queue@webkit.org
Message:

When clearing cache, also clear AVFoundation cache.
​https://bugs.webkit.org/show_bug.cgi?id=155783
rdar://problem/25252541

Patch by Jeremy Jones <​jeremyj@apple.com> on 2016-04-11
Reviewed by Darin Adler.

Source/WebCore:

Use AVAssetCache at a specified location on disk for all AVURLAssets. This AVAssetCache
can then be used to manage the cache storage used by AVFoundation. It is used to query the
contents of the cache in originsInMediaCache() and to clear the cache completely or partially in
clearMediaCache() and clearMediaCacheForOrigins().

Use SecurityOrigin instead of the less formal site String to represent origins in the cache.

  • html/HTMLMediaElement.cpp:

(WebCore::sharedMediaCacheDirectory): Added.
(WebCore::HTMLMediaElement::setMediaCacheDirectory): Added.
(WebCore::HTMLMediaElement::mediaCacheDirectory): Added.
(WebCore::HTMLMediaElement::originsInMediaCache): Added.
(WebCore::HTMLMediaElement::clearMediaCache): Added parameter.
(WebCore::HTMLMediaElement::clearMediaCacheForOrigins): Added.
(WebCore::HTMLMediaElement::mediaPlayerMediaCacheDirectory): Added.
(WebCore::HTMLMediaElement::getSitesInMediaCache): Deleted.
(WebCore::HTMLMediaElement::clearMediaCacheForSite): Deleted.

  • html/HTMLMediaElement.h:

(WebCore::HTMLMediaElement::clearMediaCache): Added parameter.

  • platform/graphics/MediaPlayer.cpp:

(WebCore::addMediaEngine): Add new cache methods.
(WebCore::addToHash): Added.
(WebCore::MediaPlayer::originsInMediaCache): Added.
(WebCore::MediaPlayer::clearMediaCache): Added parameter.
(WebCore::MediaPlayer::clearMediaCacheForOrigins): Added.
(WebCore::MediaPlayer::getSitesInMediaCache): Deleted.
(WebCore::MediaPlayer::clearMediaCacheForSite): Deleted.

  • platform/graphics/MediaPlayer.h:

(WebCore::MediaPlayerClient::mediaPlayerMediaCacheDirectory): Added.

  • platform/graphics/MediaPlayerPrivate.h:

(WebCore::MediaPlayerPrivateInterface::originsInMediaCache): Added.
(WebCore::MediaPlayerPrivateInterface::clearMediaCache): Added parameter.
(WebCore::MediaPlayerPrivateInterface::clearMediaCacheForOrigins): Added.
(WebCore::MediaPlayerPrivateInterface::getSitesInMediaCache): Deleted.
(WebCore::MediaPlayerPrivateInterface::clearMediaCacheForSite): Deleted.

  • platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
  • platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:

(WebCore::MediaPlayerPrivateAVFoundationObjC::registerMediaEngine): Added cache methods.
(WebCore::assetCacheForPath): Added.
(WebCore::MediaPlayerPrivateAVFoundationObjC::originsInMediaCache): Added.
(WebCore::toSystemClockTime): Added.
(WebCore::MediaPlayerPrivateAVFoundationObjC::clearMediaCache): Added parameter.
(WebCore::MediaPlayerPrivateAVFoundationObjC::clearMediaCacheForOrigins): Added.
(WebCore::MediaPlayerPrivateAVFoundationObjC::createAVAssetForURL): Added.

  • platform/graphics/mac/MediaPlayerPrivateQTKit.h:
  • platform/graphics/mac/MediaPlayerPrivateQTKit.mm:

(WebCore::MediaPlayerPrivateQTKit::registerMediaEngine): Added cache methods.
(WebCore::MediaPlayerPrivateQTKit::originsInMediaCache): Added.
(WebCore::MediaPlayerPrivateQTKit::clearMediaCache): Added parameter.
(WebCore::MediaPlayerPrivateQTKit::clearMediaCacheForOrigins): Added.
(WebCore::MediaPlayerPrivateQTKit::getSitesInMediaCache): Deleted.
(WebCore::MediaPlayerPrivateQTKit::clearMediaCacheForSite): Deleted.

  • platform/spi/mac/AVFoundationSPI.h:

Source/WebKit2:

Include the HTMLMediaElement media cache when doing disk cache operations.
Add a sandbox extension for media cache directory. This allows the UI process and the web process
to access the same cache.

  • Shared/WebProcessCreationParameters.cpp:

(WebKit::WebProcessCreationParameters::encode): Add media cache directory.
(WebKit::WebProcessCreationParameters::decode): Add media cache directory.

  • Shared/WebProcessCreationParameters.h:
  • UIProcess/API/APIProcessPoolConfiguration.cpp:

(API::ProcessPoolConfiguration::createWithLegacyOptions):
(API::ProcessPoolConfiguration::ProcessPoolConfiguration): Add media cache directory.
(API::ProcessPoolConfiguration::copy): Add media cache directory.

  • UIProcess/API/APIProcessPoolConfiguration.h:
  • UIProcess/API/APIWebsiteDataStore.cpp:

(API::WebsiteDataStore::defaultMediaCacheDirectory): Default implementation.

  • UIProcess/API/APIWebsiteDataStore.h:
  • UIProcess/API/Cocoa/APIWebsiteDataStoreCocoa.mm:

(API::WebsiteDataStore::defaultMediaCacheDirectory): Media cache is in temporary directory.
(API::WebsiteDataStore::tempDirectoryFileSystemRepresentation): For resources in temporary directory.
(API::WebsiteDataStore::defaultDataStoreConfiguration): Init media cache directory.

  • UIProcess/Cocoa/WebProcessPoolCocoa.mm:

(WebKit::WebProcessPool::legacyPlatformDefaultMediaCacheDirectory):

  • UIProcess/WebProcessPool.cpp:

(WebKit::legacyWebsiteDataStoreConfiguration): Add mediaCacheDirectory.
(WebKit::WebProcessPool::createNewWebProcess): Add mediaCacheDirectory.

  • UIProcess/WebProcessPool.h:
  • UIProcess/WebsiteData/WebsiteDataStore.cpp:

(WebKit::WebsiteDataStore::WebsiteDataStore):
(WebKit::WebsiteDataStore::fetchData): Implement for mediaCacheDirectory.
(WebKit::WebsiteDataStore::removeData): Implement for mediaCacheDirectory.

  • UIProcess/WebsiteData/WebsiteDataStore.h:
  • UIProcess/efl/WebProcessPoolEfl.cpp:

(WebKit::WebProcessPool::legacyPlatformDefaultMediaCacheDirectory): Added.

  • UIProcess/gtk/WebProcessPoolGtk.cpp:

(WebKit::WebProcessPool::legacyPlatformDefaultMediaCacheDirectory): Added.

  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::initializeWebProcess): Initialize media cache directory.

  • WebProcess/cocoa/WebProcessCocoa.mm:

(WebKit::WebProcess::platformInitializeWebProcess): Consume sandbox extension.

Location:
trunk/Source
Files:
28 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r199323 r199326  
     12016-04-11  Jeremy Jones  <jeremyj@apple.com>
     2
     3        When clearing cache, also clear AVFoundation cache.
     4        https://bugs.webkit.org/show_bug.cgi?id=155783
     5        rdar://problem/25252541
     6
     7        Reviewed by Darin Adler.
     8
     9        Use AVAssetCache at a specified location on disk for all AVURLAssets. This AVAssetCache
     10        can then be used to manage the cache storage used by AVFoundation. It is used to query the
     11        contents of the cache in originsInMediaCache() and to clear the cache completely or partially in
     12        clearMediaCache() and clearMediaCacheForOrigins().
     13
     14        Use SecurityOrigin instead of the less formal site String to represent origins in the cache.
     15
     16        * html/HTMLMediaElement.cpp:
     17        (WebCore::sharedMediaCacheDirectory): Added.
     18        (WebCore::HTMLMediaElement::setMediaCacheDirectory): Added.
     19        (WebCore::HTMLMediaElement::mediaCacheDirectory): Added.
     20        (WebCore::HTMLMediaElement::originsInMediaCache): Added.
     21        (WebCore::HTMLMediaElement::clearMediaCache): Added parameter.
     22        (WebCore::HTMLMediaElement::clearMediaCacheForOrigins): Added.
     23        (WebCore::HTMLMediaElement::mediaPlayerMediaCacheDirectory): Added.
     24        (WebCore::HTMLMediaElement::getSitesInMediaCache): Deleted.
     25        (WebCore::HTMLMediaElement::clearMediaCacheForSite): Deleted.
     26        * html/HTMLMediaElement.h:
     27        (WebCore::HTMLMediaElement::clearMediaCache): Added parameter.
     28        * platform/graphics/MediaPlayer.cpp:
     29        (WebCore::addMediaEngine): Add new cache methods.
     30        (WebCore::addToHash): Added.
     31        (WebCore::MediaPlayer::originsInMediaCache): Added.
     32        (WebCore::MediaPlayer::clearMediaCache): Added parameter.
     33        (WebCore::MediaPlayer::clearMediaCacheForOrigins): Added.
     34        (WebCore::MediaPlayer::getSitesInMediaCache): Deleted.
     35        (WebCore::MediaPlayer::clearMediaCacheForSite): Deleted.
     36        * platform/graphics/MediaPlayer.h:
     37        (WebCore::MediaPlayerClient::mediaPlayerMediaCacheDirectory): Added.
     38        * platform/graphics/MediaPlayerPrivate.h:
     39        (WebCore::MediaPlayerPrivateInterface::originsInMediaCache): Added.
     40        (WebCore::MediaPlayerPrivateInterface::clearMediaCache): Added parameter.
     41        (WebCore::MediaPlayerPrivateInterface::clearMediaCacheForOrigins): Added.
     42        (WebCore::MediaPlayerPrivateInterface::getSitesInMediaCache): Deleted.
     43        (WebCore::MediaPlayerPrivateInterface::clearMediaCacheForSite): Deleted.
     44        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
     45        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
     46        (WebCore::MediaPlayerPrivateAVFoundationObjC::registerMediaEngine): Added cache methods.
     47        (WebCore::assetCacheForPath): Added.
     48        (WebCore::MediaPlayerPrivateAVFoundationObjC::originsInMediaCache): Added.
     49        (WebCore::toSystemClockTime): Added.
     50        (WebCore::MediaPlayerPrivateAVFoundationObjC::clearMediaCache): Added parameter.
     51        (WebCore::MediaPlayerPrivateAVFoundationObjC::clearMediaCacheForOrigins): Added.
     52        (WebCore::MediaPlayerPrivateAVFoundationObjC::createAVAssetForURL): Added.
     53        * platform/graphics/mac/MediaPlayerPrivateQTKit.h:
     54        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
     55        (WebCore::MediaPlayerPrivateQTKit::registerMediaEngine): Added cache methods.
     56        (WebCore::MediaPlayerPrivateQTKit::originsInMediaCache): Added.
     57        (WebCore::MediaPlayerPrivateQTKit::clearMediaCache): Added parameter.
     58        (WebCore::MediaPlayerPrivateQTKit::clearMediaCacheForOrigins): Added.
     59        (WebCore::MediaPlayerPrivateQTKit::getSitesInMediaCache): Deleted.
     60        (WebCore::MediaPlayerPrivateQTKit::clearMediaCacheForSite): Deleted.
     61        * platform/spi/mac/AVFoundationSPI.h:
     62
    1632016-04-11  Commit Queue  <commit-queue@webkit.org>
    264

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r199321 r199326  
    55945594        document().decrementLoadEventDelayCount();
    55955595}
    5596    
    5597 
    5598 void HTMLMediaElement::getSitesInMediaCache(Vector<String>& sites)
    5599 {
    5600     MediaPlayer::getSitesInMediaCache(sites);
    5601 }
    5602 
    5603 void HTMLMediaElement::clearMediaCache()
    5604 {
    5605     MediaPlayer::clearMediaCache();
    5606 }
    5607 
    5608 void HTMLMediaElement::clearMediaCacheForSite(const String& site)
    5609 {
    5610     MediaPlayer::clearMediaCacheForSite(site);
     5596
     5597static String& sharedMediaCacheDirectory()
     5598{
     5599    static NeverDestroyed<String> sharedMediaCacheDirectory;
     5600    return sharedMediaCacheDirectory;
     5601}
     5602
     5603void HTMLMediaElement::setMediaCacheDirectory(const String& path)
     5604{
     5605    sharedMediaCacheDirectory() = path;
     5606}
     5607
     5608const String& HTMLMediaElement::mediaCacheDirectory()
     5609{
     5610    return sharedMediaCacheDirectory();
     5611}
     5612
     5613HashSet<RefPtr<SecurityOrigin>> HTMLMediaElement::originsInMediaCache(const String& path)
     5614{
     5615    return MediaPlayer::originsInMediaCache(path);
     5616}
     5617
     5618void HTMLMediaElement::clearMediaCache(const String& path, std::chrono::system_clock::time_point modifiedSince)
     5619{
     5620    MediaPlayer::clearMediaCache(path, modifiedSince);
     5621}
     5622
     5623void HTMLMediaElement::clearMediaCacheForOrigins(const String& path, const HashSet<RefPtr<SecurityOrigin>>& origins)
     5624{
     5625    MediaPlayer::clearMediaCacheForOrigins(path, origins);
    56115626}
    56125627
    … …  
    61936208}
    61946209
     6210const String& HTMLMediaElement::mediaPlayerMediaCacheDirectory() const
     6211{
     6212    return mediaCacheDirectory();
     6213}
     6214
    61956215bool HTMLMediaElement::mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge& challenge)
    61966216{

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r199321 r199326  
    381381
    382382    // Media cache management.
    383     WEBCORE_EXPORT static void getSitesInMediaCache(Vector<String>&);
    384     WEBCORE_EXPORT static void clearMediaCache();
    385     WEBCORE_EXPORT static void clearMediaCacheForSite(const String&);
     383    WEBCORE_EXPORT static void setMediaCacheDirectory(const String&);
     384    WEBCORE_EXPORT static const String& mediaCacheDirectory();
     385    WEBCORE_EXPORT static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String&);
     386    WEBCORE_EXPORT static void clearMediaCache(const String&, std::chrono::system_clock::time_point modifiedSince = { });
     387    WEBCORE_EXPORT static void clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>&);
    386388    static void resetMediaEngines();
    387389
    … …  
    598600    RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() override;
    599601    bool mediaPlayerShouldUsePersistentCache() const override;
     602    const String& mediaPlayerMediaCacheDirectory() const override;
    600603
    601604#if PLATFORM(WIN) && USE(AVFOUNDATION)

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.cpp

    r199321 r199326  
    171171    MediaEngineSupportedTypes getSupportedTypes;
    172172    MediaEngineSupportsType supportsTypeAndCodecs;
    173     MediaEngineGetSitesInMediaCache getSitesInMediaCache;
     173    MediaEngineOriginsInMediaCache originsInMediaCache;
    174174    MediaEngineClearMediaCache clearMediaCache;
    175     MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
     175    MediaEngineClearMediaCacheForOrigins clearMediaCacheForOrigins;
    176176    MediaEngineSupportsKeySystem supportsKeySystem;
    177177};
    178178
    179 static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
     179static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineOriginsInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForOrigins, MediaEngineSupportsKeySystem);
    180180
    181181static bool haveMediaEnginesVector;
    … …  
    235235
    236236static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
    237     MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)
     237    MediaEngineOriginsInMediaCache originsInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForOrigins clearMediaCacheForOrigins, MediaEngineSupportsKeySystem supportsKeySystem)
    238238{
    239239    ASSERT(constructor);
    … …  
    241241    ASSERT(supportsType);
    242242
    243     mutableInstalledMediaEnginesVector().append(MediaPlayerFactory { constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite, supportsKeySystem });
     243    mutableInstalledMediaEnginesVector().append(MediaPlayerFactory { constructor, getSupportedTypes, supportsType, originsInMediaCache, clearMediaCache, clearMediaCacheForOrigins, supportsKeySystem });
    244244}
    245245
    … …  
    10431043}
    10441044
    1045 void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
    1046 {
     1045template<typename T>
     1046static void addToHash(HashSet<T>& toHash, HashSet<T>&& fromHash)
     1047{
     1048    if (toHash.isEmpty())
     1049        toHash = WTFMove(fromHash);
     1050    else
     1051        toHash.add(fromHash.begin(), fromHash.end());
     1052}
     1053   
     1054HashSet<RefPtr<SecurityOrigin>> MediaPlayer::originsInMediaCache(const String& path)
     1055{
     1056    HashSet<RefPtr<SecurityOrigin>> origins;
    10471057    for (auto& engine : installedMediaEngines()) {
    1048         if (!engine.getSitesInMediaCache)
     1058        if (!engine.originsInMediaCache)
    10491059            continue;
    1050         Vector<String> engineSites;
    1051         engine.getSitesInMediaCache(engineSites);
    1052         sites.appendVector(engineSites);
     1060        addToHash(origins, engine.originsInMediaCache(path));
    10531061    }
    1054 }
    1055 
    1056 void MediaPlayer::clearMediaCache()
     1062    return origins;
     1063}
     1064
     1065void MediaPlayer::clearMediaCache(const String& path, std::chrono::system_clock::time_point modifiedSince)
    10571066{
    10581067    for (auto& engine : installedMediaEngines()) {
    10591068        if (engine.clearMediaCache)
    1060             engine.clearMediaCache();
     1069            engine.clearMediaCache(path, modifiedSince);
    10611070    }
    10621071}
    10631072
    1064 void MediaPlayer::clearMediaCacheForSite(const String& site)
     1073void MediaPlayer::clearMediaCacheForOrigins(const String& path, const HashSet<RefPtr<SecurityOrigin>>& origins)
    10651074{
    10661075    for (auto& engine : installedMediaEngines()) {
    1067         if (engine.clearMediaCacheForSite)
    1068             engine.clearMediaCacheForSite(site);
     1076        if (engine.clearMediaCacheForOrigins)
     1077            engine.clearMediaCacheForOrigins(path, origins);
    10691078    }
    10701079}

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.h

    r199321 r199326  
    4141#include "PlatformMediaResourceLoader.h"
    4242#include "PlatformMediaSession.h"
     43#include "SecurityOriginHash.h"
    4344#include "Timer.h"
    4445#include "VideoTrackPrivate.h"
    … …  
    237238    virtual bool doesHaveAttribute(const AtomicString&, AtomicString* = 0) const { return false; }
    238239    virtual bool mediaPlayerShouldUsePersistentCache() const { return true; }
     240    virtual const String& mediaPlayerMediaCacheDirectory() const { return emptyString(); }
    239241
    240242#if ENABLE(VIDEO_TRACK)
    … …  
    293295    static void getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>&);
    294296    static bool isAvailable();
    295     static void getSitesInMediaCache(Vector<String>&);
    296     static void clearMediaCache();
    297     static void clearMediaCacheForSite(const String&);
     297    static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String& path);
     298    static void clearMediaCache(const String& path, std::chrono::system_clock::time_point modifiedSince);
     299    static void clearMediaCacheForOrigins(const String& path, const HashSet<RefPtr<SecurityOrigin>>&);
    298300    static bool supportsKeySystem(const String& keySystem, const String& mimeType);
    299301
    … …  
    631633typedef void (*MediaEngineSupportedTypes)(HashSet<String, ASCIICaseInsensitiveHash>& types);
    632634typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const MediaEngineSupportParameters& parameters);
    633 typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
    634 typedef void (*MediaEngineClearMediaCache)();
    635 typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
     635typedef HashSet<RefPtr<SecurityOrigin>> (*MediaEngineOriginsInMediaCache)(const String& path);
     636typedef void (*MediaEngineClearMediaCache)(const String& path, std::chrono::system_clock::time_point modifiedSince);
     637typedef void (*MediaEngineClearMediaCacheForOrigins)(const String& path, const HashSet<RefPtr<SecurityOrigin>>&);
    636638typedef bool (*MediaEngineSupportsKeySystem)(const String& keySystem, const String& mimeType);
    637639
    638640typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType,
    639     MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
     641    MediaEngineOriginsInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForOrigins, MediaEngineSupportsKeySystem);
    640642typedef void (*MediaEngineRegister)(MediaEngineRegistrar);
    641643

  • trunk/Source/WebCore/platform/graphics/MediaPlayerPrivate.h

    r199321 r199326  
    215215    virtual unsigned videoDecodedByteCount() const { return 0; }
    216216
    217     void getSitesInMediaCache(Vector<String>&) { }
    218     void clearMediaCache() { }
    219     void clearMediaCacheForSite(const String&) { }
     217    HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String&) { return { }; }
     218    void clearMediaCache(const String&, std::chrono::system_clock::time_point) { }
     219    void clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>&) { }
    220220
    221221    virtual void setPrivateBrowsingMode(bool) { }

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h

    r199321 r199326  
    8888    static void registerMediaEngine(MediaEngineRegistrar);
    8989
     90    static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String&);
     91    static void clearMediaCache(const String&, std::chrono::system_clock::time_point modifiedSince);
     92    static void clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>&);
     93
    9094    void setAsset(RetainPtr<id>);
    9195    void tracksChanged() override;

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm

    r199321 r199326  
    159159SOFT_LINK_CLASS(AVFoundation, AVAssetImageGenerator)
    160160SOFT_LINK_CLASS(AVFoundation, AVMetadataItem)
     161SOFT_LINK_CLASS(AVFoundation, AVAssetCache)
    161162
    162163SOFT_LINK_CLASS(CoreImage, CIContext)
    … …  
    228229
    229230#if ENABLE(AVF_CAPTIONS)
     231SOFT_LINK_POINTER(AVFoundation, AVURLAssetCacheKey, NSString*)
    230232SOFT_LINK_POINTER(AVFoundation, AVURLAssetHTTPCookiesKey, NSString*)
    231233SOFT_LINK_POINTER(AVFoundation, AVURLAssetOutOfBandAlternateTracksKey, NSString*)
    … …  
    243245#define AVURLAssetHTTPCookiesKey getAVURLAssetHTTPCookiesKey()
    244246#define AVURLAssetOutOfBandAlternateTracksKey getAVURLAssetOutOfBandAlternateTracksKey()
     247#define AVURLAssetCacheKey getAVURLAssetCacheKey()
    245248#define AVURLAssetUsesNoPersistentCacheKey getAVURLAssetUsesNoPersistentCacheKey()
    246249#define AVOutOfBandAlternateTrackDisplayNameKey getAVOutOfBandAlternateTrackDisplayNameKey()
    … …  
    423426    if (isAvailable())
    424427        registrar([](MediaPlayer* player) { return std::make_unique<MediaPlayerPrivateAVFoundationObjC>(player); },
    425             getSupportedTypes, supportsType, 0, 0, 0, supportsKeySystem);
     428            getSupportedTypes, supportsType, originsInMediaCache, clearMediaCache, clearMediaCacheForOrigins, supportsKeySystem);
     429}
     430
     431static AVAssetCache *assetCacheForPath(const String& path)
     432{
     433    NSURL *assetCacheURL;
     434   
     435    if (path.isEmpty())
     436        assetCacheURL = [[NSURL fileURLWithPath:NSTemporaryDirectory()] URLByAppendingPathComponent:@"MediaCache" isDirectory:YES];
     437    else
     438        assetCacheURL = [NSURL fileURLWithPath:path isDirectory:YES];
     439
     440    return [getAVAssetCacheClass() assetCacheWithURL:assetCacheURL];
     441}
     442
     443HashSet<RefPtr<SecurityOrigin>> MediaPlayerPrivateAVFoundationObjC::originsInMediaCache(const String& path)
     444{
     445    HashSet<RefPtr<SecurityOrigin>> origins;
     446    for (NSString *key in [assetCacheForPath(path) allKeys]) {
     447        URL keyAsURL = URL(URL(), key);
     448        if (keyAsURL.isValid())
     449            origins.add(SecurityOrigin::create(keyAsURL));
     450    }
     451    return origins;
     452}
     453
     454static std::chrono::system_clock::time_point toSystemClockTime(NSDate *date)
     455{
     456    ASSERT(date);
     457    using namespace std::chrono;
     458
     459    return system_clock::time_point(duration_cast<system_clock::duration>(duration<double>(date.timeIntervalSince1970)));
     460}
     461
     462void MediaPlayerPrivateAVFoundationObjC::clearMediaCache(const String& path, std::chrono::system_clock::time_point modifiedSince)
     463{
     464    LOG(Media, "MediaPlayerPrivateAVFoundationObjC::clearMediaCache()");
     465   
     466    AVAssetCache* assetCache = assetCacheForPath(path);
     467   
     468    for (NSString *key in [assetCache allKeys]) {
     469        if (toSystemClockTime([assetCache lastModifiedDateOfEntryForKey:key]) > modifiedSince)
     470            [assetCache removeEntryForKey:key];
     471    }
     472
     473    NSFileManager *fileManager = [NSFileManager defaultManager];
     474    NSURL *baseURL = [assetCache URL];
     475
     476    if (modifiedSince <= std::chrono::system_clock::time_point { }) {
     477        [fileManager removeItemAtURL:baseURL error:nil];
     478        return;
     479    }
     480   
     481    NSArray *propertyKeys = @[NSURLNameKey, NSURLContentModificationDateKey, NSURLIsRegularFileKey];
     482    NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtURL:baseURL includingPropertiesForKeys:
     483        propertyKeys options:NSDirectoryEnumerationSkipsSubdirectoryDescendants
     484        errorHandler:nil];
     485   
     486    RetainPtr<NSMutableArray> urlsToDelete = adoptNS([[NSMutableArray alloc] init]);
     487    for (NSURL *fileURL : enumerator) {
     488        NSDictionary *fileAttributes = [fileURL resourceValuesForKeys:propertyKeys error:nil];
     489   
     490        if (![fileAttributes[NSURLNameKey] hasPrefix:@"CachedMedia-"])
     491            continue;
     492       
     493        if (![fileAttributes[NSURLIsRegularFileKey] boolValue])
     494            continue;
     495       
     496        if (toSystemClockTime(fileAttributes[NSURLContentModificationDateKey]) <= modifiedSince)
     497            continue;
     498       
     499        [urlsToDelete addObject:fileURL];
     500    }
     501   
     502    for (NSURL *fileURL in urlsToDelete.get())
     503        [fileManager removeItemAtURL:fileURL error:nil];
     504}
     505
     506void MediaPlayerPrivateAVFoundationObjC::clearMediaCacheForOrigins(const String& path, const HashSet<RefPtr<SecurityOrigin>>& origins)
     507{
     508    LOG(Media, "MediaPlayerPrivateAVFoundationObjC::clearMediaCacheForOrigins()");
     509    AVAssetCache* assetCache = assetCacheForPath(path);
     510    for (NSString *key in [assetCache allKeys]) {
     511        URL keyAsURL = URL(URL(), key);
     512        if (keyAsURL.isValid()) {
     513            if (origins.contains(SecurityOrigin::create(keyAsURL)))
     514                [assetCache removeEntryForKey:key];
     515        }
     516    }
    426517}
    427518
    … …  
    875966#endif
    876967
    877     [options setObject:[NSNumber numberWithBool:!player()->client().mediaPlayerShouldUsePersistentCache()] forKey:AVURLAssetUsesNoPersistentCacheKey];
     968    bool usePersistentCache = player()->client().mediaPlayerShouldUsePersistentCache();
     969    [options setObject:@(!usePersistentCache) forKey:AVURLAssetUsesNoPersistentCacheKey];
     970   
     971    if (usePersistentCache)
     972        [options setObject:assetCacheForPath(player()->client().mediaPlayerMediaCacheDirectory()) forKey:AVURLAssetCacheKey];
    878973
    879974    NSURL *cocoaURL = canonicalURL(url);

  • trunk/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h

    r199321 r199326  
    6969    static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
    7070
    71     static void getSitesInMediaCache(Vector<String>&);
    72     static void clearMediaCache();
    73     static void clearMediaCacheForSite(const String&);
     71    static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String&);
     72    static void clearMediaCache(const String&, std::chrono::system_clock::time_point modifiedSince);
     73    static void clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>&);
    7474    static bool isAvailable();
    7575

  • trunk/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm

    r199321 r199326  
    176176    if (isAvailable())
    177177        registrar([](MediaPlayer* player) { return std::make_unique<MediaPlayerPrivateQTKit>(player); }, getSupportedTypes,
    178             supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite, 0);
     178            supportsType, originsInMediaCache, clearMediaCache, clearMediaCacheForOrigins, 0);
    179179}
    180180
    … …  
    13401340}
    13411341
    1342 void MediaPlayerPrivateQTKit::getSitesInMediaCache(Vector<String>& sites)
    1343 {
     1342HashSet<RefPtr<SecurityOrigin>> MediaPlayerPrivateQTKit::originsInMediaCache(const String&)
     1343{
     1344    HashSet<RefPtr<SecurityOrigin>> origins;
    13441345    NSArray *mediaSites = wkQTGetSitesInMediaDownloadCache();
    1345     for (NSString *site in mediaSites)
    1346         sites.append(site);
    1347 }
    1348 
    1349 void MediaPlayerPrivateQTKit::clearMediaCache()
     1346   
     1347    for (NSString *site in mediaSites) {
     1348        URL siteAsURL = URL(URL(), site);
     1349        if (siteAsURL.isValid())
     1350            origins.add(SecurityOrigin::create(siteAsURL));
     1351    }
     1352    return origins;
     1353}
     1354
     1355void MediaPlayerPrivateQTKit::clearMediaCache(const String&, std::chrono::system_clock::time_point)
    13501356{
    13511357    LOG(Media, "MediaPlayerPrivateQTKit::clearMediaCache()");
    … …  
    13531359}
    13541360
    1355 void MediaPlayerPrivateQTKit::clearMediaCacheForSite(const String& site)
    1356 {
    1357     LOG(Media, "MediaPlayerPrivateQTKit::clearMediaCacheForSite()");
    1358     wkQTClearMediaDownloadCacheForSite(site);
     1361void MediaPlayerPrivateQTKit::clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>& origins)
     1362{
     1363    LOG(Media, "MediaPlayerPrivateQTKit::clearMediaCacheForOrigins()");
     1364    for (auto& origin : origins)
     1365        wkQTClearMediaDownloadCacheForSite(origin->toRawString());
    13591366}
    13601367

  • trunk/Source/WebCore/platform/spi/mac/AVFoundationSPI.h

    r199321 r199326  
    5656#endif // ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS)
    5757
     58#if USE(APPLE_INTERNAL_SDK)
     59#import <AVFoundation/AVAssetCache_Private.h>
     60#else
     61NS_ASSUME_NONNULL_BEGIN
     62@interface AVAssetCache : NSObject
     63+ (AVAssetCache *)assetCacheWithURL:(NSURL *)URL;
     64- (id)initWithURL:(NSURL *)URL;
     65- (NSArray *)allKeys;
     66- (NSDate *)lastModifiedDateOfEntryForKey:(NSString *)key;
     67- (void)removeEntryForKey:(NSString *)key;
     68@property (nonatomic, readonly, copy) NSURL *URL;
     69@end
     70NS_ASSUME_NONNULL_END
     71#endif
     72
    5873#if PLATFORM(IOS)
    5974

  • trunk/Source/WebKit2/ChangeLog

    r199321 r199326  
     12016-04-11  Jeremy Jones  <jeremyj@apple.com>
     2
     3        When clearing cache, also clear AVFoundation cache.
     4        https://bugs.webkit.org/show_bug.cgi?id=155783
     5        rdar://problem/25252541
     6
     7        Reviewed by Darin Adler.
     8
     9        Include the HTMLMediaElement media cache when doing disk cache operations.
     10        Add a sandbox extension for media cache directory. This allows the UI process and the web process
     11        to access the same cache.
     12
     13        * Shared/WebProcessCreationParameters.cpp:
     14        (WebKit::WebProcessCreationParameters::encode): Add media cache directory.
     15        (WebKit::WebProcessCreationParameters::decode): Add media cache directory.
     16        * Shared/WebProcessCreationParameters.h:
     17        * UIProcess/API/APIProcessPoolConfiguration.cpp:
     18        (API::ProcessPoolConfiguration::createWithLegacyOptions):
     19        (API::ProcessPoolConfiguration::ProcessPoolConfiguration): Add media cache directory.
     20        (API::ProcessPoolConfiguration::copy): Add media cache directory.
     21        * UIProcess/API/APIProcessPoolConfiguration.h:
     22        * UIProcess/API/APIWebsiteDataStore.cpp:
     23        (API::WebsiteDataStore::defaultMediaCacheDirectory): Default implementation.
     24        * UIProcess/API/APIWebsiteDataStore.h:
     25        * UIProcess/API/Cocoa/APIWebsiteDataStoreCocoa.mm:
     26        (API::WebsiteDataStore::defaultMediaCacheDirectory): Media cache is in temporary directory.
     27        (API::WebsiteDataStore::tempDirectoryFileSystemRepresentation): For resources in temporary directory.
     28        (API::WebsiteDataStore::defaultDataStoreConfiguration): Init media cache directory.
     29        * UIProcess/Cocoa/WebProcessPoolCocoa.mm:
     30        (WebKit::WebProcessPool::legacyPlatformDefaultMediaCacheDirectory):
     31        * UIProcess/WebProcessPool.cpp:
     32        (WebKit::legacyWebsiteDataStoreConfiguration): Add mediaCacheDirectory.
     33        (WebKit::WebProcessPool::createNewWebProcess): Add mediaCacheDirectory.
     34        * UIProcess/WebProcessPool.h:
     35        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
     36        (WebKit::WebsiteDataStore::WebsiteDataStore):
     37        (WebKit::WebsiteDataStore::fetchData): Implement for mediaCacheDirectory.
     38        (WebKit::WebsiteDataStore::removeData): Implement for mediaCacheDirectory.
     39        * UIProcess/WebsiteData/WebsiteDataStore.h:
     40        * UIProcess/efl/WebProcessPoolEfl.cpp:
     41        (WebKit::WebProcessPool::legacyPlatformDefaultMediaCacheDirectory): Added.
     42        * UIProcess/gtk/WebProcessPoolGtk.cpp:
     43        (WebKit::WebProcessPool::legacyPlatformDefaultMediaCacheDirectory): Added.
     44        * WebProcess/WebProcess.cpp:
     45        (WebKit::WebProcess::initializeWebProcess): Initialize media cache directory.
     46        * WebProcess/cocoa/WebProcessCocoa.mm:
     47        (WebKit::WebProcess::platformInitializeWebProcess): Consume sandbox extension.
     48
    1492016-04-11  Commit Queue  <commit-queue@webkit.org>
    250

  • trunk/Source/WebKit2/Shared/WebProcessCreationParameters.cpp

    r199321 r199326  
    6666    encoder << webSQLDatabaseDirectory;
    6767    encoder << webSQLDatabaseDirectoryExtensionHandle;
     68    encoder << mediaCacheDirectory;
     69    encoder << mediaCacheDirectoryExtensionHandle;
    6870#if ENABLE(SECCOMP_FILTERS)
    6971    encoder << cookieStorageDirectory;
    … …  
    160162    if (!decoder.decode(parameters.webSQLDatabaseDirectoryExtensionHandle))
    161163        return false;
     164    if (!decoder.decode(parameters.mediaCacheDirectory))
     165        return false;
     166    if (!decoder.decode(parameters.mediaCacheDirectoryExtensionHandle))
     167        return false;
    162168#if ENABLE(SECCOMP_FILTERS)
    163169    if (!decoder.decode(parameters.cookieStorageDirectory))

  • trunk/Source/WebKit2/Shared/WebProcessCreationParameters.h

    r199321 r199326  
    7373    String webSQLDatabaseDirectory;
    7474    SandboxExtension::Handle webSQLDatabaseDirectoryExtensionHandle;
     75    String mediaCacheDirectory;
     76    SandboxExtension::Handle mediaCacheDirectoryExtensionHandle;
    7577#if ENABLE(SECCOMP_FILTERS)
    7678    String cookieStorageDirectory;

  • trunk/Source/WebKit2/UIProcess/API/APIProcessPoolConfiguration.cpp

    r199321 r199326  
    4747    configuration->m_applicationCacheDirectory = WebKit::WebProcessPool::legacyPlatformDefaultApplicationCacheDirectory();
    4848    configuration->m_diskCacheDirectory = WebKit::WebProcessPool::legacyPlatformDefaultNetworkCacheDirectory();
     49    configuration->m_mediaCacheDirectory = WebKit::WebProcessPool::legacyPlatformDefaultMediaCacheDirectory();
    4950    configuration->m_indexedDBDatabaseDirectory = WebKit::WebProcessPool::legacyPlatformDefaultIndexedDBDatabaseDirectory();
    5051    configuration->m_localStorageDirectory = WebKit::WebProcessPool::legacyPlatformDefaultLocalStorageDirectory();
    … …  
    5859    : m_applicationCacheDirectory(WebsiteDataStore::defaultApplicationCacheDirectory())
    5960    , m_diskCacheDirectory(WebsiteDataStore::defaultNetworkCacheDirectory())
     61    , m_mediaCacheDirectory(WebsiteDataStore::defaultMediaCacheDirectory())
    6062    , m_indexedDBDatabaseDirectory(WebsiteDataStore::defaultIndexedDBDatabaseDirectory())
    6163    , m_localStorageDirectory(WebsiteDataStore::defaultLocalStorageDirectory())
    … …  
    8082    copy->m_applicationCacheDirectory = this->m_applicationCacheDirectory;
    8183    copy->m_diskCacheDirectory = this->m_diskCacheDirectory;
     84    copy->m_mediaCacheDirectory = this->m_mediaCacheDirectory;
    8285    copy->m_indexedDBDatabaseDirectory = this->m_indexedDBDatabaseDirectory;
    8386    copy->m_injectedBundlePath = this->m_injectedBundlePath;

  • trunk/Source/WebKit2/UIProcess/API/APIProcessPoolConfiguration.h

    r199321 r199326  
    6666    void setDiskCacheDirectory(const WTF::String& diskCacheDirectory) { m_diskCacheDirectory = diskCacheDirectory; }
    6767
     68    const WTF::String& mediaCacheDirectory() const { return m_mediaCacheDirectory; }
     69    void setMediaCacheDirectory(const WTF::String& mediaCacheDirectory) { m_mediaCacheDirectory = mediaCacheDirectory; }
     70   
    6871    const WTF::String& indexedDBDatabaseDirectory() const { return m_indexedDBDatabaseDirectory; }
    6972    void setIndexedDBDatabaseDirectory(const WTF::String& indexedDBDatabaseDirectory) { m_indexedDBDatabaseDirectory = indexedDBDatabaseDirectory; }
    … …  
    103106    WTF::String m_applicationCacheDirectory;
    104107    WTF::String m_diskCacheDirectory;
     108    WTF::String m_mediaCacheDirectory;
    105109    WTF::String m_indexedDBDatabaseDirectory;
    106110    WTF::String m_injectedBundlePath;

  • trunk/Source/WebKit2/UIProcess/API/APIWebsiteDataStore.cpp

    r199321 r199326  
    138138
    139139#endif
     140   
     141#if !PLATFORM(COCOA)
     142String WebsiteDataStore::defaultMediaCacheDirectory()
     143{
     144    // FIXME: Implement. https://bugs.webkit.org/show_bug.cgi?id=156369 and https://bugs.webkit.org/show_bug.cgi?id=156370
     145    return String();
     146}
     147#endif
    140148
    141149}

  • trunk/Source/WebKit2/UIProcess/API/APIWebsiteDataStore.h

    r199321 r199326  
    5050    static String defaultApplicationCacheDirectory();
    5151    static String defaultNetworkCacheDirectory();
     52    static String defaultMediaCacheDirectory();
    5253
    5354    static String defaultIndexedDBDatabaseDirectory();
    … …  
    6162    WebsiteDataStore();
    6263
     64    static String tempDirectoryFileSystemRepresentation(const String& directoryName);
    6365    static String cacheDirectoryFileSystemRepresentation(const String& directoryName);
    6466    static String websiteDataDirectoryFileSystemRepresentation(const String& directoryName);

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/APIWebsiteDataStoreCocoa.mm

    r199321 r199326  
    5858}
    5959
     60String WebsiteDataStore::defaultMediaCacheDirectory()
     61{
     62    return tempDirectoryFileSystemRepresentation("MediaCache");
     63}
     64
    6065String WebsiteDataStore::defaultIndexedDBDatabaseDirectory()
    6166{
    … …  
    8186{
    8287    return websiteDataDirectoryFileSystemRepresentation("ResourceLoadStatistics");
     88}
     89
     90String WebsiteDataStore::tempDirectoryFileSystemRepresentation(const String& directoryName)
     91{
     92    static dispatch_once_t onceToken;
     93    static NSURL *tempURL;
     94   
     95    dispatch_once(&onceToken, ^{
     96        NSURL *url = [NSURL fileURLWithPath:NSTemporaryDirectory()];
     97        if (!url)
     98            RELEASE_ASSERT_NOT_REACHED();
     99       
     100        if (!WebKit::processHasContainer()) {
     101            NSString *bundleIdentifier = [NSBundle mainBundle].bundleIdentifier;
     102            if (!bundleIdentifier)
     103                bundleIdentifier = [NSProcessInfo processInfo].processName;
     104            url = [url URLByAppendingPathComponent:bundleIdentifier isDirectory:YES];
     105        }
     106       
     107        tempURL = [[url URLByAppendingPathComponent:@"WebKit" isDirectory:YES] retain];
     108    });
     109   
     110    NSURL *url = [tempURL URLByAppendingPathComponent:directoryName isDirectory:YES];
     111    if (![[NSFileManager defaultManager] createDirectoryAtURL:url withIntermediateDirectories:YES attributes:nil error:nullptr])
     112        LOG_ERROR("Failed to create directory %@", url);
     113   
     114    return url.absoluteURL.path.fileSystemRepresentation;
    83115}
    84116
    … …  
    145177    configuration.applicationCacheDirectory = defaultApplicationCacheDirectory();
    146178    configuration.networkCacheDirectory = defaultNetworkCacheDirectory();
     179    configuration.mediaCacheDirectory = defaultMediaCacheDirectory();
    147180
    148181    configuration.webSQLDatabaseDirectory = defaultWebSQLDatabaseDirectory();

  • trunk/Source/WebKit2/UIProcess/Cocoa/WebProcessPoolCocoa.mm

    r199321 r199326  
    6565NSString *WebKitJSCFTLJITEnabledDefaultsKey = @"WebKitJSCFTLJITEnabledDefaultsKey";
    6666NSString *WebKitMediaKeysStorageDirectoryDefaultsKey = @"WebKitMediaKeysStorageDirectory";
     67NSString *WebKitMediaCacheDirectoryDefaultsKey = @"WebKitMediaCacheDirectory";
    6768
    6869#if !PLATFORM(IOS)
    … …  
    335336        localStorageDirectory = @"~/Library/WebKit/LocalStorage";
    336337    return stringByResolvingSymlinksInPath([localStorageDirectory stringByStandardizingPath]);
     338}
     339
     340String WebProcessPool::legacyPlatformDefaultMediaCacheDirectory()
     341{
     342    registerUserDefaultsIfNeeded();
     343   
     344    NSString *mediaKeysCacheDirectory = [[NSUserDefaults standardUserDefaults] objectForKey:WebKitMediaCacheDirectoryDefaultsKey];
     345    if (!mediaKeysCacheDirectory || ![mediaKeysCacheDirectory isKindOfClass:[NSString class]]) {
     346        mediaKeysCacheDirectory = NSTemporaryDirectory();
     347       
     348        if (!WebKit::processHasContainer()) {
     349            NSString *bundleIdentifier = [NSBundle mainBundle].bundleIdentifier;
     350            if (!bundleIdentifier)
     351                bundleIdentifier = [NSProcessInfo processInfo].processName;
     352            mediaKeysCacheDirectory = [mediaKeysCacheDirectory stringByAppendingPathComponent:bundleIdentifier];
     353        }
     354        mediaKeysCacheDirectory = [mediaKeysCacheDirectory stringByAppendingPathComponent:@"WebKit/MediaCache"];
     355    }
     356    return stringByResolvingSymlinksInPath([mediaKeysCacheDirectory stringByStandardizingPath]);
    337357}
    338358

  • trunk/Source/WebKit2/UIProcess/WebProcessPool.cpp

    r199321 r199326  
    129129    configuration.webSQLDatabaseDirectory = processPoolConfiguration.webSQLDatabaseDirectory();
    130130    configuration.applicationCacheDirectory = processPoolConfiguration.applicationCacheDirectory();
     131    configuration.mediaCacheDirectory = processPoolConfiguration.mediaCacheDirectory();
    131132    configuration.mediaKeysStorageDirectory = processPoolConfiguration.mediaKeysStorageDirectory();
    132133    configuration.networkCacheDirectory = processPoolConfiguration.diskCacheDirectory();
    … …  
    545546        SandboxExtension::createHandleForReadWriteDirectory(parameters.webSQLDatabaseDirectory, parameters.webSQLDatabaseDirectoryExtensionHandle);
    546547
     548    parameters.mediaCacheDirectory = m_configuration->mediaCacheDirectory();
     549    if (!parameters.mediaCacheDirectory.isEmpty())
     550        SandboxExtension::createHandleForReadWriteDirectory(parameters.mediaCacheDirectory, parameters.mediaCacheDirectoryExtensionHandle);
     551   
    547552#if ENABLE(SECCOMP_FILTERS)
    548553    parameters.cookieStorageDirectory = this->cookieStorageDirectory();

  • trunk/Source/WebKit2/UIProcess/WebProcessPool.h

    r199321 r199326  
    362362    static String legacyPlatformDefaultWebSQLDatabaseDirectory();
    363363    static String legacyPlatformDefaultMediaKeysStorageDirectory();
     364    static String legacyPlatformDefaultMediaCacheDirectory();
    364365    static String legacyPlatformDefaultApplicationCacheDirectory();
    365366    static String legacyPlatformDefaultNetworkCacheDirectory();

  • trunk/Source/WebKit2/UIProcess/WebsiteData/WebsiteDataStore.cpp

    r199321 r199326  
    3838#include <WebCore/ApplicationCacheStorage.h>
    3939#include <WebCore/DatabaseTracker.h>
     40#include <WebCore/HTMLMediaElement.h>
    4041#include <WebCore/OriginLock.h>
    4142#include <WebCore/SecurityOrigin.h>
    … …  
    7879    , m_networkCacheDirectory(WTFMove(configuration.networkCacheDirectory))
    7980    , m_applicationCacheDirectory(WTFMove(configuration.applicationCacheDirectory))
     81    , m_mediaCacheDirectory(WTFMove(configuration.mediaCacheDirectory))
    8082    , m_webSQLDatabaseDirectory(WTFMove(configuration.webSQLDatabaseDirectory))
    8183    , m_mediaKeysStorageDirectory(WTFMove(configuration.mediaKeysStorageDirectory))
    … …  
    255257
    256258    RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(fetchOptions, WTFMove(completionHandler)));
     259
     260    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
     261        StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
     262       
     263        callbackAggregator->addPendingCallback();
     264        m_queue->dispatch([fetchOptions, mediaCacheDirectory, callbackAggregator] {
     265            HashSet<RefPtr<WebCore::SecurityOrigin>> origins = WebCore::HTMLMediaElement::originsInMediaCache(mediaCacheDirectory.string());
     266            WebsiteData* websiteData = new WebsiteData;
     267           
     268            for (auto& origin : origins) {
     269                WebsiteData::Entry entry { origin, WebsiteDataType::DiskCache, 0 };
     270                websiteData->entries.append(WTFMove(entry));
     271            }
     272           
     273            WTF::RunLoop::main().dispatch([callbackAggregator, origins, websiteData] {
     274                callbackAggregator->removePendingCallback(WTFMove(*websiteData));
     275               
     276                delete websiteData;
     277            });
     278        });
     279    }
    257280
    258281    auto networkProcessAccessType = computeNetworkProcessAccessTypeForDataFetch(dataTypes, !isPersistent());
    … …  
    530553    RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(WTFMove(completionHandler)));
    531554
     555    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
     556        StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
     557
     558        callbackAggregator->addPendingCallback();
     559        m_queue->dispatch([modifiedSince, mediaCacheDirectory, callbackAggregator] {
     560            WebCore::HTMLMediaElement::clearMediaCache(mediaCacheDirectory.string(), modifiedSince);
     561           
     562            WTF::RunLoop::main().dispatch([callbackAggregator] {
     563                callbackAggregator->removePendingCallback();
     564            });
     565        });
     566    }
     567
    532568    auto networkProcessAccessType = computeNetworkProcessAccessTypeForDataRemoval(dataTypes, !isPersistent());
    533569    if (networkProcessAccessType != ProcessAccessType::None) {
    … …  
    756792
    757793    RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(WTFMove(completionHandler)));
    758 
     794   
     795    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
     796        StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
     797        HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
     798        for (const auto& dataRecord : dataRecords) {
     799            for (const auto& origin : dataRecord.origins)
     800                origins.add(origin);
     801        }
     802       
     803        callbackAggregator->addPendingCallback();
     804        m_queue->dispatch([origins, mediaCacheDirectory, callbackAggregator] {
     805            WebCore::HTMLMediaElement::clearMediaCacheForOrigins(mediaCacheDirectory.string(), origins);
     806           
     807            WTF::RunLoop::main().dispatch([callbackAggregator] {
     808                callbackAggregator->removePendingCallback();
     809            });
     810        });
     811    }
     812   
    759813    auto networkProcessAccessType = computeNetworkProcessAccessTypeForDataRemoval(dataTypes, !isPersistent());
    760814    if (networkProcessAccessType != ProcessAccessType::None) {

  • trunk/Source/WebKit2/UIProcess/WebsiteData/WebsiteDataStore.h

    r199321 r199326  
    6262        String applicationCacheDirectory;
    6363
     64        String mediaCacheDirectory;
    6465        String webSQLDatabaseDirectory;
    6566        String localStorageDirectory;
    … …  
    118119    const String m_networkCacheDirectory;
    119120    const String m_applicationCacheDirectory;
     121    const String m_mediaCacheDirectory;
    120122
    121123    const String m_webSQLDatabaseDirectory;

  • trunk/Source/WebKit2/UIProcess/efl/WebProcessPoolEfl.cpp

    r199321 r199326  
    8888}
    8989
     90String WebProcessPool::legacyPlatformDefaultMediaCacheDirectory()
     91{
     92    return API::WebsiteDataStore::defaultMediaCacheDirectory();
     93}
     94
    9095void WebProcessPool::platformInitializeWebProcess(WebProcessCreationParameters& parameters)
    9196{

  • trunk/Source/WebKit2/UIProcess/gtk/WebProcessPoolGtk.cpp

    r199321 r199326  
    8787}
    8888
     89WTF::String WebProcessPool::legacyPlatformDefaultMediaCacheDirectory()
     90{
     91    return API::WebsiteDataStore::defaultMediaCacheDirectory();
     92}
     93
    8994void WebProcessPool::platformInitializeWebProcess(WebProcessCreationParameters& parameters)
    9095{

  • trunk/Source/WebKit2/WebProcess/WebProcess.cpp

    r199321 r199326  
    7878#include <WebCore/GCController.h>
    7979#include <WebCore/GlyphPage.h>
     80#include <WebCore/HTMLMediaElement.h>
    8081#include <WebCore/IconDatabase.h>
    8182#include <WebCore/JSDOMWindow.h>
    … …  
    294295        ApplicationCacheStorage::singleton().setCacheDirectory(parameters.applicationCacheDirectory);
    295296
     297    if (!parameters.mediaCacheDirectory.isEmpty())
     298        WebCore::HTMLMediaElement::setMediaCacheDirectory(parameters.mediaCacheDirectory);
     299
    296300    setCacheModel(static_cast<uint32_t>(parameters.cacheModel));
    297301

  • trunk/Source/WebKit2/WebProcess/cocoa/WebProcessCocoa.mm

    r199321 r199326  
    136136    SandboxExtension::consumePermanently(parameters.webSQLDatabaseDirectoryExtensionHandle);
    137137    SandboxExtension::consumePermanently(parameters.applicationCacheDirectoryExtensionHandle);
     138    SandboxExtension::consumePermanently(parameters.mediaCacheDirectoryExtensionHandle);
    138139    SandboxExtension::consumePermanently(parameters.mediaKeyStorageDirectoryExtensionHandle);
    139140#if PLATFORM(IOS)
Note: See TracChangeset for help on using the changeset viewer.