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;
 
+class Resource::CacheHandler : public CachedMetadataHandler {
+public:
+    static PassOwnPtr<CacheHandler> create(Resource* resource)
+    {
+        return adoptPtr(new CacheHandler(resource));
+    }
+    ~CacheHandler() override { }
+    void setCachedMetadata(unsigned, const char*, size_t, CacheType) override;
+    void clearCachedMetadata(CacheType) override;
+    CachedMetadata* cachedMetadata(unsigned) const override;
+    String encoding() const override;
+
+private:
+    explicit CacheHandler(Resource*);
+    Resource* m_resource;
+};
+
+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_loadFinishTime(0)
     , m_identifier(0)
     , m_encodedSize(0)
     , m_decodedSize(0)
     , m_handleCount(0)
     , m_preloadCount(0)
@@ skipping 20 matching lines @@
 #endif
     memoryCache()->registerLiveResource(*this);
 
     if (!m_resourceRequest.url().hasFragmentIdentifier())
         return;
     KURL urlForCache = MemoryCache::removeFragmentIdentifierIfNeeded(m_resourceRequest.url());
     if (urlForCache.hasFragmentIdentifier())
         return;
     m_fragmentIdentifierForRequest = m_resourceRequest.url().fragmentIdentifier();
     m_resourceRequest.setURL(urlForCache);
+
+    if (url().protocolIsInHTTPFamily())

[vogelheim, 2015/02/16 17:29:50]

nitpick: This is exactly right, but maybe add a 1 line comment why it's there,
since it's bit non-obvious merely from reading the code.

[horo, 2015/02/16 17:54:26]

Done.

+        m_cacheHandler = CacheHandler::create(this);
 }
 
 Resource::~Resource()
 {
     ASSERT(!m_resourceToRevalidate); // Should be true because canDelete() checks this.
     ASSERT(canDelete());
     RELEASE_ASSERT(!memoryCache()->contains(this));
     RELEASE_ASSERT(!ResourceCallback::callbackHandler()->isScheduled(this));
     assertAlive();
 
@@ skipping 264 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.get();
+}
+
+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
 
 }