CachedMetadata support for ServiceWorker script.

Source/core/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 78 matching lines @@
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(headerPrefixesToIgnoreAfterRevalidation); i++) {
         if (header.startsWith(headerPrefixesToIgnoreAfterRevalidation[i], false))
             return false;
     }
     return true;
 }
 
 DEFINE_DEBUG_ONLY_GLOBAL(RefCountedLeakCounter, cachedResourceLeakCounter, ("Resource"));
 unsigned Resource::s_instanceCount = 0;
 
+Resource::CacheHandler::CacheHandler(Resource* resource)
+    : m_resource(resource)
+{
+}
+
+void Resource::CacheHandler::setCachedMetadata(unsigned dataTypeID, const char* data, size_t size, CacheType type)
+{
+    m_resource->setCachedMetadata(dataTypeID, data, size, type);
+}
+
+void Resource::CacheHandler::clearCachedMetadata(CacheType type)
+{
+    m_resource->clearCachedMetadata(type);
+}
+
+CachedMetadata* Resource::CacheHandler::cachedMetadata(unsigned dataTypeID) const
+{
+    return m_resource->cachedMetadata(dataTypeID);
+}
+
+String Resource::CacheHandler::encoding() const
+{
+    return m_resource->encoding();
+}
+
+
 Resource::Resource(const ResourceRequest& request, Type type)
     : m_resourceRequest(request)
     , m_responseTimestamp(currentTime())
     , m_cancelTimer(this, &Resource::cancelTimerFired)
+    , m_cacheHandler(this)
     , m_loadFinishTime(0)
     , m_identifier(0)
     , m_encodedSize(0)
     , m_decodedSize(0)
     , m_handleCount(0)
     , m_preloadCount(0)
     , m_protectorCount(0)
     , m_cacheIdentifier(MemoryCache::defaultCacheIdentifier())
     , m_preloadResult(PreloadNotReferenced)
     , m_requestedFromNetworkingLayer(false)
@@ skipping 300 matching lines @@
 {
     // We only expect to receive cached metadata from the platform once.
     // If this triggers, it indicates an efficiency problem which is most
     // likely unexpected in code designed to improve performance.
     ASSERT(!m_cachedMetadata);
     ASSERT(!m_resourceToRevalidate);
 
     m_cachedMetadata = CachedMetadata::deserialize(data, size);
 }
 
-void Resource::setCachedMetadata(unsigned dataTypeID, const char* data, size_t size, MetadataCacheType cacheType)
+CachedMetadataHandler* Resource::cacheHandler()
+{
+    return &m_cacheHandler;

[vogelheim, 2015/02/16 13:12:04]

This might not be correct: Not all Resources are cacheable; e.g. the default
cache impl will refuse to cache URLs belonging to extensions. In this case, this
would return a CachedMetadataHandler instance that will CHECK-fault on pretty
much every use of it.

Technically, whether that is correct depends on how you define the API :), but
it seems more sensible to only return an instance that is actually usable. You
might to something like:
  return protocolIsInHTTPFamily() ? &m_cacheHandler : nullptr;

See also the somewhat long-ish explanation at V8ScriptRunner.cpp, because this
would have a direct impact.

[horo, 2015/02/16 16:20:11]

Done.

+}
+
+void Resource::setCachedMetadata(unsigned dataTypeID, const char* data, size_t size, CachedMetadataHandler::CacheType cacheType)
 {
     // Currently, only one type of cached metadata per resource is supported.
     // If the need arises for multiple types of metadata per resource this could
     // be enhanced to store types of metadata in a map.
     ASSERT(!m_cachedMetadata);
 
     m_cachedMetadata = CachedMetadata::create(dataTypeID, data, size);
 
     // We don't support sending the metadata to the platform when the response
     // was fetched via a ServiceWorker to prevent an attacker's Service Worker
     // from poisoning the metadata cache.
     // FIXME: Support sending the metadata even if the response was fetched via
     // a ServiceWorker. https://crbug.com/448706
-    if (cacheType == SendToPlatform && !m_response.wasFetchedViaServiceWorker()) {
+    if (cacheType == CachedMetadataHandler::SendToPlatform && !m_response.wasFetchedViaServiceWorker()) {
         const Vector<char>& serializedData = m_cachedMetadata->serialize();
         blink::Platform::current()->cacheMetadata(m_response.url(), m_response.responseTime(), serializedData.data(), serializedData.size());
     }
 }
 
-void Resource::clearCachedMetadata(MetadataCacheType cacheType)
+void Resource::clearCachedMetadata(CachedMetadataHandler::CacheType cacheType)
 {
     m_cachedMetadata.clear();
 
-    if (cacheType == SendToPlatform)
+    if (cacheType == CachedMetadataHandler::SendToPlatform)
         blink::Platform::current()->cacheMetadata(m_response.url(), m_response.responseTime(), 0, 0);
 }
 
 bool Resource::canDelete() const
 {
     return !hasClients() && !m_loader && !m_preloadCount && hasRightHandleCountApartFromCache(0)
         && !m_protectorCount && !m_resourceToRevalidate && !m_proxyResource;
 }
 
 bool Resource::hasOneHandle() const
@@ skipping 564 matching lines @@
         return "ImportResource";
     case Resource::Media:
         return "Media";
     }
     ASSERT_NOT_REACHED();
     return "Unknown";
 }
 #endif // !LOG_DISABLED
 
 }