Revert of Revalidate using the same Resource, attempt #2

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 103 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);
 
     void addClient(ResourceClient*);
     void removeClient(ResourceClient*);
     bool hasClients() const { return !m_clients.isEmpty() || !m_clientsAwaitingCallback.isEmpty(); }
@@ skipping 89 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();
 
     double currentAge() const;
     double freshnessLifetime();
     double stalenessLifetime();
 
     bool isPurgeable() const;
     bool wasPurged() const;
     bool lock();
 
@@ skipping 15 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;
 
     class ResourceCallback {
     public:
         static ResourceCallback* callbackHandler();
         void schedule(Resource*);
         void cancel(Resource*);
@@ skipping 17 matching lines @@
 
         ResourceRequest m_request;
         ResourceResponse m_redirectResponse;
     };
     const Vector<RedirectPair>& redirectChain() const { return m_redirectChain; }
 
     virtual bool isSafeToUnlock() const { return false; }
     virtual void destroyDecodedDataIfPossible() { }
 
     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;
 
@@ skipping 44 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 {
 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