干货：深入理解 WKWebView -- 探究 WebKit 缓存

// HTTP 磁盘缓存。WKWebsiteDataTypeDiskCache,
// html离线Web应用程序缓存。WKWebsiteDataTypeOfflineWebApplicationCache, 
// HTTP 内存缓存。WKWebsiteDataTypeMemoryCache, 
// 会话存储:存储对数据只有在同一个会话中的页面才能访问并且当会话结束后数据也随之销毁。// 因此sessionStorage不是一种持久化的本地存储，仅仅是会话级别的存储WKWebsiteDataTypeSessionStorage, 
// 本地存储：localStorage 类似 sessionStorage，但其区别在于,存储在 localStorage 的数据可以长期保留.WKWebsiteDataTypeLocalStorage, 
// Cookies存储:存储所有的cookie数据 WKWebsiteDataTypeCookies, 
// IndexedDB数据库:IndexedDB是WebSQL数据库的取代品。IndexedDB是key-value型数据库，操作简单。WKWebsiteDataTypeIndexedDBDatabases, 
// webSQL数据库:W3C组织在2010年11月18日废弃了webSql 数据库，该数据库接口操组复杂，对用户不友好。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 }; //通过定时器触发，到过期时间后，进行资源清理 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;    }    ...    //创建 SuspendedPageProxy 变量，此时 m_suspendedPageCount 的值会加一     auto suspendedPage = makeUnique(*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: 指定删除的网站数据类型，date: 在此日期之后修改的所有网站数据将被删除，completionHandler: 当网站数据被删除时调用的block。[[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:websiteDataTypes modifiedSince:dateFrom completionHandler:^{ // 结束回调 }];

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); }

// 网络请求加载是否使用内存缓存有如下策略：enum RevalidationPolicy { Use, // 直接使用Revalidate, // 需要经过 HTTP 缓存协议校验Reload, // 重新加载，清理内存缓存，并重新请求Load // 直接从网络加载};
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 maxStale) {    if (response.cacheControlContainsNoCache())         return UseDecision::Validate; 

    // 当前过去的时间 = 当前时间 - 资源时间 ｜ computeCurrentAge     auto age = WebCore::computeCurrentAge(response, timestamp);     // 调用资源有效时间计算 ｜ 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 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 发起请求     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.         // 是否应该更新请求头         if (!shouldUpdateHeaderAfterRevalidation(header.key))             continue;         response.setHTTPHeaderField(header.key, header.value);     }}