CachedMetadata support for ServiceWorker script.

Source/core/fetch/Resource.cpp

Index: Source/core/fetch/Resource.cpp
diff --git a/Source/core/fetch/Resource.cpp b/Source/core/fetch/Resource.cpp
index 34d307d1c78f046a2526726fa3fa9ba79dd47ebb..f3c5419a022c5fe7970285b1a77c8ac35e60ccc5 100644
--- a/Source/core/fetch/Resource.cpp
+++ b/Source/core/fetch/Resource.cpp
@@ -96,10 +96,37 @@ static inline bool shouldUpdateHeaderAfterRevalidation(const AtomicString& heade
 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)
@@ -420,7 +447,12 @@ void Resource::setSerializedCachedMetadata(const char* data, size_t size)
     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
@@ -434,17 +466,17 @@ void Resource::setCachedMetadata(unsigned dataTypeID, const char* data, size_t s
     // 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);
 }