深入理解 WKWebView（基礎(chǔ)篇）-- 探究 WebKit 緩存

// HTTP 磁盤緩存。WKWebsiteDataTypeDiskCache,
// html離線Web應(yīng)用程序緩存。WKWebsiteDataTypeOfflineWebApplicationCache, 
// HTTP 內(nèi)存緩存。WKWebsiteDataTypeMemoryCache, 
// 會話存儲:存儲對數(shù)據(jù)只有在同一個會話中的頁面才能訪問并且當會話結(jié)束后數(shù)據(jù)也隨之銷毀。// 因此sessionStorage不是一種持久化的本地存儲，僅僅是會話級別的存儲WKWebsiteDataTypeSessionStorage, 
// 本地存儲：localStorage 類似 sessionStorage，但其區(qū)別在于,存儲在 localStorage 的數(shù)據(jù)可以長期保留.WKWebsiteDataTypeLocalStorage, 
// Cookies存儲:存儲所有的cookie數(shù)據(jù) WKWebsiteDataTypeCookies, 
// IndexedDB數(shù)據(jù)庫:IndexedDB是WebSQL數(shù)據(jù)庫的取代品。IndexedDB是key-value型數(shù)據(jù)庫，操作簡單。WKWebsiteDataTypeIndexedDBDatabases, 
// webSQL數(shù)據(jù)庫:W3C組織在2010年11月18日廢棄了webSql 數(shù)據(jù)庫，該數(shù)據(jù)庫接口操組復(fù)雜，對用戶不友好。WKWebsiteDataTypeWebSQLDatabases

// back/forward cache capacity (in pages)if (memorySize >= 512)    backForwardCacheCapacity = 2;else if (memorySize >= 256)    backForwardCacheCapacity = 1;else    backForwardCacheCapacity = 0;

static const Seconds expirationDelay { 30_min }; //通過定時器觸發(fā)，到過期時間后，進行資源清理 void WebBackForwardCacheEntry::expirationTimerFired() {    RELEASE_LOG(BackForwardCache, "%p - WebBackForwardCacheEntry::expirationTimerFired backForwardItemID=%s, hasSuspendedPage=%d", this, m_backForwardItemID.string().utf8().data(), !!m_suspendedPage);    ASSERT(m_backForwardItemID);    auto* item = WebBackForwardListItem::itemForID(m_backForwardItemID);    ASSERT(item);    m_backForwardCache.removeEntry(*item); // Will destroy |this|.}

void BackForwardCache::prune(PruningReason pruningReason) {    while (pageCount() > maxSize()) {         auto oldestItem = m_items.takeFirst();         oldestItem->setCachedPage(nullptr);         oldestItem->m_pruningReason = pruningReason;         RELEASE_LOG(BackForwardCache, "BackForwardCache::prune removing item: %s, size: %u / %u", oldestItem->identifier().string().utf8().data(), pageCount(), maxSize());    }}

bool WebPageProxy::suspendCurrentPageIfPossible(...) {    ...    // If the source and the destination back / forward list items are the same, then this is a client-side redirect. In this case,     // there is no need to suspend the previous page as there will be no way to get back to it.     if (fromItem && fromItem == m_backForwardList->currentItem()) {         RELEASE_LOG_IF_ALLOWED(ProcessSwapping, "suspendCurrentPageIfPossible: Not suspending current page for process pid %i because this is a client-side redirect", m_process->processIdentifier());         return false;    }    ...    //創(chuàng)建 SuspendedPageProxy 變量，此時 m_suspendedPageCount 的值會加一     auto suspendedPage = makeUnique<SuspendedPageProxy>(*this, m_process.copyRef(), *mainFrameID, shouldDelayClosingUntilFirstLayerFlush);     m_lastSuspendedPage = makeWeakPtr(*suspendedPage);     ...    //添加進歷史棧緩存     backForwardCache().addEntry(*fromItem, WTFMove(suspendedPage));     ...}

 NSString *libraryDir = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory,NSUserDomainMask, YES)[0]; NSString *bundleId = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleIdentifier"]; NSString *webkitFolderInLib = [NSString stringWithFormat:@"%@/WebKit",libraryDir]; NSString *webKitFolderInCaches = [NSString stringWithFormat:@"%@/Caches/%@/WebKit",libraryDir,bundleId]; NSError *error; [[NSFileManager defaultManager] removeItemAtPath:webKitFolderInCaches error:&error]; [[NSFileManager defaultManager] removeItemAtPath:webkitFolderInLib error:nil];

NSSet *websiteDataTypes = [NSSet setWithArray:@[ WKWebsiteDataTypeDiskCache, WKWebsiteDataTypeOfflineWebApplicationCache, WKWebsiteDataTypeLocalStorage, WKWebsiteDataTypeCookies, WKWebsiteDataTypeSessionStorage, WKWebsiteDataTypeIndexedDBDatabases, WKWebsiteDataTypeWebSQLDatabases ]];NSDate *dateFrom = [NSDate dateWithTimeIntervalSince1970:0]; //dataTypes: 指定刪除的網(wǎng)站數(shù)據(jù)類型，date: 在此日期之后修改的所有網(wǎng)站數(shù)據(jù)將被刪除，completionHandler: 當網(wǎng)站數(shù)據(jù)被刪除時調(diào)用的block。[[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:websiteDataTypes modifiedSince:dateFrom completionHandler:^{ // 結(jié)束回調(diào) }];

case CacheModel::PrimaryWebBrowser: {     // back/forward cache capacity (in pages)     if (memorySize >= 512)         backForwardCacheCapacity = 2;     else if (memorySize >= 256)         backForwardCacheCapacity = 1;     else         backForwardCacheCapacity = 0;     // Object cache capacities (in bytes)     // (Testing indicates that value / MB depends heavily on content and     // browsing pattern. Even growth above 128MB can have substantial     // value / MB for some content / browsing patterns.)     if (memorySize >= 2048)         cacheTotalCapacity = 128 * MB;     else if (memorySize >= 1536)         cacheTotalCapacity = 96 * MB;     else if (memorySize >= 1024)         cacheTotalCapacity = 64 * MB;     else if (memorySize >= 512)         cacheTotalCapacity = 32 * MB;     else         cacheTotalCapacity = 16 * MB;     cacheMinDeadCapacity = cacheTotalCapacity / 4;     cacheMaxDeadCapacity = cacheTotalCapacity / 2;     // This code is here to avoid a PLT regression. We can remove it if we     // can prove that the overall system gain would justify the regression.     cacheMaxDeadCapacity = std::max(24u, cacheMaxDeadCapacity);     deadDecodedDataDeletionInterval = 60_s;     break; }

bool MemoryCache::add(CachedResource& resource) {    if (disabled())         return false;     if (resource.resourceRequest().httpMethod() != "GET")         return false;     ASSERT(WTF::isMainThread());     auto key = std::make_pair(resource.url(), resource.cachePartition());     ensureSessionResourceMap(resource.sessionID()).set(key, &resource);     resource.setInCache(true);     resourceAccessed(resource);     LOG(ResourceLoading, "MemoryCache::add Added '%.255s', resource %p\n", resource.url().string().latin1().data(), &resource);     return true; }

CachedResource* MemoryCache::resourceForRequest(const ResourceRequest& request, PAL::SessionID sessionID) {    // FIXME: Change all clients to make sure HTTP(s) URLs have no fragment identifiers before calling here.     // CachedResourceLoader is now doing this. Add an assertion once all other clients are doing it too.     auto* resources = sessionResourceMap(sessionID);     if (!resources)         return nullptr;     return resourceForRequestImpl(request, *resources); }
CachedResource* MemoryCache::resourceForRequestImpl(const ResourceRequest& request, CachedResourceMap& resources) {    ASSERT(WTF::isMainThread());     URL url = removeFragmentIdentifierIfNeeded(request.url());     auto key = std::make_pair(url, request.cachePartition());     return resources.get(key); }

// 網(wǎng)絡(luò)請求加載是否使用內(nèi)存緩存有如下策略：enum RevalidationPolicy { Use, // 直接使用Revalidate, // 需要經(jīng)過 HTTP 緩存協(xié)議校驗Reload, // 重新加載，清理內(nèi)存緩存，并重新請求Load // 直接從網(wǎng)絡(luò)加載};
RevalidationPolicy policy = determineRevalidationPolicy(type, request, resource.get(), forPreload, imageLoading);

case CacheModel::PrimaryWebBrowser: { 
        // Disk cache capacity (in bytes)         if (diskFreeSize >= 16384)             urlCacheDiskCapacity = 1 * GB;         else if (diskFreeSize >= 8192)             urlCacheDiskCapacity = 500 * MB;         else if (diskFreeSize >= 4096)             urlCacheDiskCapacity = 250 * MB;         else if (diskFreeSize >= 2048)             urlCacheDiskCapacity = 200 * MB;         else if (diskFreeSize >= 1024)             urlCacheDiskCapacity = 150 * MB;         else             urlCacheDiskCapacity = 100 * MB; 
        break;     }    default:         ASSERT_NOT_REACHED();     };

// WebKit/Source/WebKit/NetworkProcess/cache/NetworkCache.cppstatic StoreDecision makeStoreDecision(const WebCore::ResourceRequest& originalRequest, const WebCore::ResourceResponse& response, size_t bodySize){    if (!originalRequest.url().protocolIsInHTTPFamily() || !response.isInHTTPFamily())        return StoreDecision::NoDueToProtocol;

    if (originalRequest.httpMethod() != "GET")        return StoreDecision::NoDueToHTTPMethod;

    auto requestDirectives = WebCore::parseCacheControlDirectives(originalRequest.httpHeaderFields());    if (requestDirectives.noStore)        return StoreDecision::NoDueToNoStoreRequest;

    if (response.cacheControlContainsNoStore())        return StoreDecision::NoDueToNoStoreResponse;

    if (!WebCore::isStatusCodeCacheableByDefault(response.httpStatusCode())) {        // http://tools.ietf.org/html/rfc7234#section-4.3.2        bool hasExpirationHeaders = response.expires() || response.cacheControlMaxAge();        bool expirationHeadersAllowCaching = WebCore::isStatusCodePotentiallyCacheable(response.httpStatusCode()) && hasExpirationHeaders;        if (!expirationHeadersAllowCaching)            return StoreDecision::NoDueToHTTPStatusCode;    }

    bool isMainResource = originalRequest.requester() == WebCore::ResourceRequest::Requester::Main;    bool storeUnconditionallyForHistoryNavigation = isMainResource || originalRequest.priority() == WebCore::ResourceLoadPriority::VeryHigh;     if (!storeUnconditionallyForHistoryNavigation) {        auto now = WallTime::now();        Seconds allowedStale { 0_ms };#if ENABLE(NETWORK_CACHE_STALE_WHILE_REVALIDATE)        if (auto value = response.cacheControlStaleWhileRevalidate())            allowedStale = value.value();#endif        bool hasNonZeroLifetime = !response.cacheControlContainsNoCache() && (WebCore::computeFreshnessLifetimeForHTTPFamily(response, now) > 0_ms || allowedStale > 0_ms);        bool possiblyReusable = response.hasCacheValidatorFields() || hasNonZeroLifetime;        if (!possiblyReusable)            return StoreDecision::NoDueToUnlikelyToReuse;    }

    // Media loaded via XHR is likely being used for MSE streaming (YouTube and Netflix for example).    // Streaming media fills the cache quickly and is unlikely to be reused.    // FIXME: We should introduce a separate media cache partition that doesn't affect other resources.    // FIXME: We should also make sure make the MSE paths are copy-free so we can use mapped buffers from disk effectively.    auto requester = originalRequest.requester();    bool isDefinitelyStreamingMedia = requester == WebCore::ResourceRequest::Requester::Media;    bool isLikelyStreamingMedia = requester == WebCore::ResourceRequest::Requester::XHR && isMediaMIMEType(response.mimeType());    if (isLikelyStreamingMedia || isDefinitelyStreamingMedia)        return StoreDecision::NoDueToStreamingMedia;

    return StoreDecision::Yes;}

// WebKit/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& request) {    ASSERT(request.cachePolicy() != WebCore::ResourceRequestCachePolicy::DoNotUseAnyCache); 

    // FIXME: Support HEAD requests.     if (request.httpMethod() != "GET")         return RetrieveDecision::NoDueToHTTPMethod;     if (request.cachePolicy() == WebCore::ResourceRequestCachePolicy::ReloadIgnoringCacheData && !request.isConditional())         return RetrieveDecision::NoDueToReloadIgnoringCache; 

    return RetrieveDecision::Yes; }

// WebKit/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp static UseDecision makeUseDecision(NetworkProcess& networkProcess, const PAL::SessionID& sessionID, const Entry& entry, const WebCore::ResourceRequest& request) {    // The request is conditional so we force revalidation from the network. We merely check the disk cache     // so we can update the cache entry.     // 條件請求判斷 ｜ bool ResourceRequestBase::isConditional     if (request.isConditional() && !entry.redirectRequest())         return UseDecision::Validate; 

    // 校驗變化的請求頭 ｜ verifyVaryingRequestHeaders     if (!WebCore::verifyVaryingRequestHeaders(networkProcess.storageSession(sessionID), entry.varyingRequestHeaders(), request))         return UseDecision::NoDueToVaryingHeaderMismatch; 

    // We never revalidate in the case of a history navigation.     // 校驗緩存是否過期 ｜ cachePolicyAllowsExpired     if (cachePolicyAllowsExpired(request.cachePolicy()))          return UseDecision::Use;

    // 驗證請求是否過期     auto decision = responseNeedsRevalidation(*networkProcess.networkSession(sessionID), entry.response(), request, entry.timeStamp());     if (decision != UseDecision::Validate)         return decision; 

    // 驗證緩存有效字端（Etag等） ｜ bool ResourceResponseBase::hasCacheValidatorFields()     if (!entry.response().hasCacheValidatorFields())         return UseDecision::NoDueToMissingValidatorFields; 

    return entry.redirectRequest() ? UseDecision::NoDueToExpiredRedirect : UseDecision::Validate; }

// WebKit/Source/WebCore/platform/network/CacheValidation.cpp Seconds computeFreshnessLifetimeForHTTPFamily(const ResourceResponse& response, WallTime responseTime) {    if (!response.url().protocolIsInHTTPFamily())        return 0_us; 

    // Freshness Lifetime:     // http://tools.ietf.org/html/rfc7234#section-4.2.1     auto maxAge = response.cacheControlMaxAge();    if (maxAge)         return *maxAge; 

    auto date = response.date();     auto effectiveDate = date.valueOr(responseTime);     if (auto expires = response.expires())         return *expires - effectiveDate; 

    // Implicit lifetime.     switch (response.httpStatusCode()) {     case 301: // Moved Permanently     case 410: // Gone         // These are semantically permanent and so get long implicit lifetime.         return 24_h * 365;     default:         // Heuristic Freshness:         // http://tools.ietf.org/html/rfc7234#section-4.2.2         if (auto lastModified = response.lastModified())             return (effectiveDate - *lastModified) * 0.1;         return 0_us;     }}

// WebKit/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp static UseDecision responseNeedsRevalidation(NetworkSession& networkSession, const WebCore::ResourceResponse& response, WallTime timestamp, Optional<Seconds> maxStale) {    if (response.cacheControlContainsNoCache())         return UseDecision::Validate; 

    // 當前過去的時間 = 當前時間 - 資源時間 ｜ computeCurrentAge     auto age = WebCore::computeCurrentAge(response, timestamp);     // 調(diào)用資源有效時間計算 ｜ computeFreshnessLifetimeForHTTPFamily     auto lifetime = WebCore::computeFreshnessLifetimeForHTTPFamily(response, timestamp); 

    // 資源允許過期時間     auto maximumStaleness = maxStale ? maxStale.value() : 0_ms;     // qy6_detail 資源是否超期 ｜ 當前過去的時間 - 資源有效時間 - 允許過期時間 > 0 => 資源過期了     bool hasExpired = age - lifetime > maximumStaleness; #if ENABLE(NETWORK_CACHE_STALE_WHILE_REVALIDATE)     if (hasExpired && !maxStale && networkSession.isStaleWhileRevalidateEnabled()) {         auto responseMaxStaleness = response.cacheControlStaleWhileRevalidate();         maximumStaleness += responseMaxStaleness ? responseMaxStaleness.value() : 0_ms;         bool inResponseStaleness = age - lifetime < maximumStaleness;         if (inResponseStaleness)             return UseDecision::AsyncRevalidate;     }#endif 

    if (hasExpired) { #ifndef LOG_DISABLED         LOG(NetworkCache, "(NetworkProcess) needsRevalidation hasExpired age=%f lifetime=%f max-staleness=%f", age, lifetime, maximumStaleness); #endif         return UseDecision::Validate;     }

    return UseDecision::Use; }

// WebKit/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp void NetworkResourceLoader::validateCacheEntry(std::unique_ptr<NetworkCache::Entry> entry) {    RELEASE_LOG_IF_ALLOWED("validateCacheEntry:");     ASSERT(!m_networkLoad); 

    // If the request is already conditional then the revalidation was not triggered by the disk cache     // and we should not overwrite the existing conditional headers.     // 如果請求為條件請求，不修改 HEADER 中條件請求屬性     ResourceRequest revalidationRequest = originalRequest();     if (!revalidationRequest.isConditional()) {         String eTag = entry->response().httpHeaderField(HTTPHeaderName::ETag);         String lastModified = entry->response().httpHeaderField(HTTPHeaderName::LastModified);         // qy6_detail 新增緩存校驗請求頭，IfNoneMatch 和 IfModifiedSince         if (!eTag.isEmpty())            revalidationRequest.setHTTPHeaderField(HTTPHeaderName::IfNoneMatch, eTag);         if (!lastModified.isEmpty())             revalidationRequest.setHTTPHeaderField(HTTPHeaderName::IfModifiedSince, lastModified);     }

    m_cacheEntryForValidation = WTFMove(entry); 

    // qy6_detail 發(fā)起請求     startNetworkLoad(WTFMove(revalidationRequest), FirstLoad::Yes); }

// WebKit/Source/WebCore/platform/network/CacheValidation.cpp void updateResponseHeadersAfterRevalidation(ResourceResponse& response, const ResourceResponse& validatingResponse) {    // Freshening stored response upon validation:     // http://tools.ietf.org/html/rfc7234#section-4.3.4     for (const auto& header : validatingResponse.httpHeaderFields()) {         // Entity headers should not be sent by servers when generating a 304         // response; misconfigured servers send them anyway. We shouldn't allow         // such headers to update the original request. We'll base this on the         // list defined by RFC2616 7.1, with a few additions for extension headers         // we care about.         // 是否應(yīng)該更新請求頭         if (!shouldUpdateHeaderAfterRevalidation(header.key))             continue;         response.setHTTPHeaderField(header.key, header.value);     }}