Revert of Revalidate using the same Resource, attempt #3

third_party/WebKit/Source/core/fetch/Resource.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@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
     version 2 of the License, or (at your option) any later version.
@@ skipping 106 matching lines @@
 
     void setIdentifier(unsigned long identifier) { m_identifier = identifier; }
     unsigned long identifier() const { return m_identifier; }
 
     virtual bool shouldIgnoreHTTPStatusCodeErrors() const { return false; }
 
     ResourceRequest& mutableResourceRequest() { return m_resourceRequest; }
     const ResourceRequest& resourceRequest() const { return m_resourceRequest; }
     const ResourceRequest& lastResourceRequest() const;
 
-    void setRevalidatingRequest(const ResourceRequest& request) { m_revalidatingRequest = request; }
-
     const KURL& url() const { return m_resourceRequest.url();}
     Type type() const { return static_cast<Type>(m_type); }
     const ResourceLoaderOptions& options() const { return m_options; }
     void setOptions(const ResourceLoaderOptions& options) { m_options = options; }
 
     void didChangePriority(ResourceLoadPriority, int intraPriorityValue);
     ResourcePriority priorityFromClients();
 
     void addClient(ResourceClient*);
     void removeClient(ResourceClient*);
-    bool hasClients() const { return !m_clients.isEmpty() || !m_clientsAwaitingCallback.isEmpty() || !m_finishedClients.isEmpty(); }
+    bool hasClients() const { return !m_clients.isEmpty() || !m_clientsAwaitingCallback.isEmpty(); }
     bool deleteIfPossible();
 
     enum PreloadResult {
         PreloadNotReferenced,
         PreloadReferenced,
         PreloadReferencedWhileLoading,
         PreloadReferencedWhileComplete
     };
     PreloadResult preloadResult() const { return static_cast<PreloadResult>(m_preloadResult); }
 
@@ skipping 79 matching lines @@
     bool isPreloaded() const { return m_preloadCount; }
     void increasePreloadCount() { ++m_preloadCount; }
     void decreasePreloadCount() { ASSERT(m_preloadCount); --m_preloadCount; }
 
     void registerHandle(ResourcePtrBase* h);
     void unregisterHandle(ResourcePtrBase* h);
 
     bool canReuseRedirectChain();
     bool mustRevalidateDueToCacheHeaders();
     bool canUseCacheValidator();
-    bool isCacheValidator() const { return !m_revalidatingRequest.isNull(); }
+    bool isCacheValidator() const { return m_resourceToRevalidate; }
+    Resource* resourceToRevalidate() const { return m_resourceToRevalidate; }
+    void setResourceToRevalidate(Resource*);
     bool hasCacheControlNoStoreHeader();
     bool hasVaryHeader() const;
     virtual bool mustRefetchDueToIntegrityMetadata(const FetchRequest& request) const { return false; }
 
     double currentAge() const;
     double freshnessLifetime();
     double stalenessLifetime();
 
     bool isPurgeable() const;
     bool wasPurged() const;
@@ skipping 17 matching lines @@
 #ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
     void assertAlive() const { RELEASE_ASSERT(!m_deleted); }
 #else
     void assertAlive() const { }
 #endif
 
 protected:
     virtual void checkNotify();
     virtual void finishOnePart();
 
-    virtual void destroyDecodedDataForFailedRevalidation() { }
-
     // Normal resource pointers will silently switch what Resource* they reference when we
     // successfully revalidated the resource. We need a way to guarantee that the Resource
     // that received the 304 response survives long enough to switch everything over to the
     // revalidatedresource. The normal mechanisms for keeping a Resource alive externally
     // (ResourcePtrs and ResourceClients registering themselves) don't work in this case, so
     // have a separate internal protector).
     class InternalResourcePtr {
     public:
         explicit InternalResourcePtr(Resource* resource)
             : m_resource(resource)
@@ skipping 10 matching lines @@
         Resource* m_resource;
     };
 
     void incrementProtectorCount() { m_protectorCount++; }
     void decrementProtectorCount() { m_protectorCount--; }
 
     void setEncodedSize(size_t);
     void setDecodedSize(size_t);
     void didAccessDecodedData();
 
+    void clearResourceToRevalidate();
+    void updateResponseAfterRevalidation(const ResourceResponse& validatingResponse);
+
     void finishPendingClients();
 
     HashCountedSet<ResourceClient*> m_clients;
     HashCountedSet<ResourceClient*> m_clientsAwaitingCallback;
-    HashCountedSet<ResourceClient*> m_finishedClients;
 
     class ResourceCallback : public NoBaseWillBeGarbageCollectedFinalized<ResourceCallback> {
     public:
         static ResourceCallback* callbackHandler();
         DECLARE_TRACE();
         void schedule(Resource*);
         void cancel(Resource*);
         bool isScheduled(Resource*) const;
     private:
         ResourceCallback();
         void runTask();
         OwnPtr<CancellableTaskFactory> m_callbackTaskFactory;
         WillBeHeapHashSet<RawPtrWillBeMember<Resource>> m_resourcesWithPendingClients;
     };
 
-    bool hasClient(ResourceClient* client) { return m_clients.contains(client) || m_clientsAwaitingCallback.contains(client) || m_finishedClients.contains(client); }
+    bool hasClient(ResourceClient* client) { return m_clients.contains(client) || m_clientsAwaitingCallback.contains(client); }
 
     struct RedirectPair {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
         explicit RedirectPair(const ResourceRequest& request, const ResourceResponse& redirectResponse)
             : m_request(request)
             , m_redirectResponse(redirectResponse)
         {
         }
 
         ResourceRequest m_request;
         ResourceResponse m_redirectResponse;
     };
     const Vector<RedirectPair>& redirectChain() const { return m_redirectChain; }
 
     virtual bool isSafeToUnlock() const { return false; }
     virtual void destroyDecodedDataIfPossible() { }
 
-    void markClientsFinished();
-
     ResourceRequest m_resourceRequest;
-    ResourceRequest m_revalidatingRequest;
     AtomicString m_accept;
     PersistentWillBeMember<ResourceLoader> m_loader;
     ResourceLoaderOptions m_options;
 
     ResourceResponse m_response;
     double m_responseTimestamp;
 
     RefPtr<SharedBuffer> m_data;
     Timer<Resource> m_cancelTimer;
 
 private:
     class CacheHandler;
+    bool addClientToSet(ResourceClient*);
     void cancelTimerFired(Timer<Resource>*);
 
     void switchClientsToRevalidatedResource();
     void revalidationSucceeded(const ResourceResponse&);
     void revalidationFailed();
 
     bool unlock();
 
     bool hasRightHandleCountApartFromCache(unsigned targetCount) const;
 
@@ skipping 31 matching lines @@
     unsigned m_status : 3; // Status
 
     unsigned m_wasPurged : 1;
 
     unsigned m_needsSynchronousCacheHit : 1;
 
 #ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
     bool m_deleted;
 #endif
 
+    // If this field is non-null we are using the resource as a proxy for checking whether an existing resource is still up to date
+    // using HTTP If-Modified-Since/If-None-Match headers. If the response is 304 all clients of this resource are moved
+    // to to be clients of m_resourceToRevalidate and the resource is deleted. If not, the field is zeroed and this
+    // resources becomes normal resource load.
+    RawPtrWillBeMember<Resource> m_resourceToRevalidate;
+
+    // If this field is non-null, the resource has a proxy for checking whether it is still up to date (see m_resourceToRevalidate).
+    RawPtrWillBeMember<Resource> m_proxyResource;
+
+    // These handles will need to be updated to point to the m_resourceToRevalidate in case we get 304 response.
+    HashSet<ResourcePtrBase*> m_handlesToRevalidate;
+
     // Ordered list of all redirects followed while fetching this resource.
     Vector<RedirectPair> m_redirectChain;
 };
 
 class ResourceFactory {
     STACK_ALLOCATED();
 public:
     virtual Resource* create(const ResourceRequest&, const String&) const = 0;
     Resource::Type type() const { return m_type; }
 
 protected:
     ResourceFactory(Resource::Type type) : m_type(type) { }
 
     Resource::Type m_type;
 };
 
 #if !LOG_DISABLED
 // Intended to be used in LOG statements.
 const char* ResourceTypeName(Resource::Type);
 #endif
 
 #define DEFINE_RESOURCE_TYPE_CASTS(typeName) \
     DEFINE_TYPE_CASTS(typeName##Resource, Resource, resource, resource->type() == Resource::typeName, resource.type() == Resource::typeName); \
     inline typeName##Resource* to##typeName##Resource(const ResourcePtr<Resource>& ptr) { return to##typeName##Resource(ptr.get()); }
 
 }
 
 #endif