C++ ApplicationCacheResource::url方法代码示例

void ApplicationCacheHost::fillResourceList(ResourceInfoList* resources)
{
    ApplicationCache* cache = applicationCache();
    if (!cache || !cache->isComplete())
        return;

    for (const auto& urlAndResource : cache->resources()) {
        ApplicationCacheResource* resource = urlAndResource.value.get();

        unsigned type = resource->type();
        bool isMaster = type & ApplicationCacheResource::Master;
        bool isManifest = type & ApplicationCacheResource::Manifest;
        bool isExplicit = type & ApplicationCacheResource::Explicit;
        bool isForeign = type & ApplicationCacheResource::Foreign;
        bool isFallback = type & ApplicationCacheResource::Fallback;

        resources->append(ResourceInfo(resource->url(), isMaster, isManifest, isFallback, isForeign, isExplicit, resource->estimatedSizeInStorage()));
    }
}

void MediaPlayerPrivateAVFoundation::setPreload(MediaPlayer::Preload preload)
{
    m_preload = preload;
    if (!m_assetURL.length())
        return;

    setDelayCallbacks(true);

    if (m_preload >= MediaPlayer::MetaData && assetStatus() == MediaPlayerAVAssetStatusDoesNotExist) {
#if ENABLE(OFFLINE_WEB_APPLICATIONS)
        Frame* frame = m_player->frameView() ? m_player->frameView()->frame() : 0;
        ApplicationCacheHost* cacheHost = frame ? frame->loader()->documentLoader()->applicationCacheHost() : 0;
        ApplicationCacheResource* resource;
        if (cacheHost && cacheHost->shouldLoadResourceFromApplicationCache(ResourceRequest(m_assetURL), resource) && resource) {
            // AVFoundation can't open arbitrary data pointers, so if this ApplicationCacheResource doesn't 
            // have a valid local path, just open the resource's original URL.
            if (resource->path().isEmpty())
                createAVAssetForURL(resource->url());
            else
                createAVAssetForCacheResource(resource);
        } else
#endif    
            createAVAssetForURL(m_assetURL);

        createAVPlayer();

        checkPlayability();
    }

    // Don't force creation of the player item unless we already know that the asset is playable. If we aren't
    // there yet, or if we already know it is not playable, creating it now won't help.
    if (m_preload == MediaPlayer::Auto && m_assetIsPlayable)
        createAVPlayerItem();

    setDelayCallbacks(false);
}

bool ApplicationCacheStorage::storeCopyOfCache(const String& cacheDirectory, ApplicationCacheHost* cacheHost)
{
    ApplicationCache* cache = cacheHost->applicationCache();
    if (!cache)
        return true;

    // Create a new cache.
    RefPtr<ApplicationCache> cacheCopy = ApplicationCache::create();

    cacheCopy->setOnlineWhitelist(cache->onlineWhitelist());
    cacheCopy->setFallbackURLs(cache->fallbackURLs());

    // Traverse the cache and add copies of all resources.
    ApplicationCache::ResourceMap::const_iterator end = cache->end();
    for (ApplicationCache::ResourceMap::const_iterator it = cache->begin(); it != end; ++it) {
        ApplicationCacheResource* resource = it->second.get();
        
        RefPtr<ApplicationCacheResource> resourceCopy = ApplicationCacheResource::create(resource->url(), resource->response(), resource->type(), resource->data());
        
        cacheCopy->addResource(resourceCopy.release());
    }
    
    // Now create a new cache group.
    OwnPtr<ApplicationCacheGroup> groupCopy(new ApplicationCacheGroup(cache->group()->manifestURL(), true));
    
    groupCopy->setNewestCache(cacheCopy);
    
    ApplicationCacheStorage copyStorage;
    copyStorage.setCacheDirectory(cacheDirectory);
    
    // Empty the cache in case something was there before.
    copyStorage.empty();
    
    return copyStorage.storeNewestCache(groupCopy.get());
}