Don't keep a separate m_revalidatingRequest on Resource

third_party/WebKit/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 293 matching lines @@
     , m_decodedSize(0)
     , m_overheadSize(calculateOverheadSize())
     , m_preloadCount(0)
     , m_preloadDiscoveryTime(0.0)
     , m_cacheIdentifier(MemoryCache::defaultCacheIdentifier())
     , m_preloadResult(PreloadNotReferenced)
     , m_type(type)
     , m_status(NotStarted)
     , m_needsSynchronousCacheHit(false)
     , m_linkPreload(false)
+    , m_isRevalidating(false)
 {
     ASSERT(m_type == unsigned(type)); // m_type is a bitfield, so this tests careless updates of the enum.
     InstanceCounters::incrementCounter(InstanceCounters::ResourceCounter);
 
     // Currently we support the metadata caching only for HTTP family.
     if (m_resourceRequest.url().protocolIsInHTTPFamily())
         m_cacheHandler = CachedMetadataHandlerImpl::create(this);
 }
 
 Resource::~Resource()
@@ skipping 11 matching lines @@
 {
     // TOOD(japhet): Temporary, out of place hack to stop a top crasher.
     // Make this more organic.
     if (!fetcher->loadingTaskRunner())
         return;
 
     RELEASE_ASSERT(!m_loader);
     ASSERT(stillNeedsLoad());
     m_status = Pending;
 
-    ResourceRequest& request(m_revalidatingRequest.isNull() ? m_resourceRequest : m_revalidatingRequest);
-    KURL url = request.url();
-    request.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
+    KURL url = m_resourceRequest.url();
+    m_resourceRequest.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
 
     m_fetcherSecurityOrigin = fetcher->context().getSecurityOrigin();
     m_loader = ResourceLoader::create(fetcher, this);
-    m_loader->start(request);
-    // If the request reference is null (i.e., a synchronous revalidation will
-    // null the request), don't make the request non-null by setting the url.
-    if (!request.isNull())
-        request.setURL(url);
+    m_loader->start(m_resourceRequest);
+    m_resourceRequest.setURL(url);
 }
 
 void Resource::checkNotify()
 {
     if (isLoading())
         return;
 
     ResourceClientWalker<ResourceClient> w(m_clients);
     while (ResourceClient* c = w.next())
         c->notifyFinished(this);
 }
 
 void Resource::appendData(const char* data, size_t length)
 {
     TRACE_EVENT0("blink", "Resource::appendData");
-    ASSERT(m_revalidatingRequest.isNull());
+    DCHECK(!m_isRevalidating);
     ASSERT(!errorOccurred());
     if (m_options.dataBufferingPolicy == DoNotBufferData)
         return;
     if (m_data)
         m_data->append(data, length);
     else
         m_data = SharedBuffer::createPurgeable(data, length);
     setEncodedSize(m_data->size());
 }
 
 void Resource::setResourceBuffer(PassRefPtr<SharedBuffer> resourceBuffer)
 {
-    ASSERT(m_revalidatingRequest.isNull());
+    DCHECK(!m_isRevalidating);
     ASSERT(!errorOccurred());
     ASSERT(m_options.dataBufferingPolicy == BufferData);
     m_data = resourceBuffer;
     setEncodedSize(m_data->size());
 }
 
 void Resource::setDataBufferingPolicy(DataBufferingPolicy dataBufferingPolicy)
 {
     m_options.dataBufferingPolicy = dataBufferingPolicy;
     m_data.clear();
     setEncodedSize(0);
 }
 
 void Resource::markClientsAndObserversFinished()
 {
     while (!m_clients.isEmpty()) {
         HashCountedSet<ResourceClient*>::iterator it = m_clients.begin();
         for (int i = it->value; i; i--) {
             m_finishedClients.add(it->key);
             m_clients.remove(it);
         }
     }
 }
 
 void Resource::error(const ResourceError& error)
 {
     ASSERT(!error.isNull());
     m_error = error;
-    if (!m_revalidatingRequest.isNull())
-        m_revalidatingRequest = ResourceRequest();
+    m_isRevalidating = false;
 
     if (m_error.isCancellation() || !isPreloaded())
         memoryCache()->remove(this);
 
     setStatus(LoadError);
     ASSERT(errorOccurred());
     m_data.clear();
     m_loader = nullptr;
     checkNotify();
     markClientsAndObserversFinished();
 }
 
 void Resource::finish(double loadFinishTime)
 {
-    ASSERT(m_revalidatingRequest.isNull());
+    DCHECK(!m_isRevalidating);
     m_loadFinishTime = loadFinishTime;
     if (!errorOccurred())
         m_status = Cached;
     m_loader = nullptr;
     checkNotify();
     markClientsAndObserversFinished();
 }
 
 AtomicString Resource::httpContentType() const
 {
@@ skipping 102 matching lines @@
 const ResourceRequest& Resource::lastResourceRequest() const
 {
     if (!m_redirectChain.size())
         return m_resourceRequest;
     return m_redirectChain.last().m_request;
 }
 
 void Resource::setRevalidatingRequest(const ResourceRequest& request)
 {
     SECURITY_CHECK(m_redirectChain.isEmpty());
-    m_revalidatingRequest = request;
+    DCHECK(!request.isNull());
+    m_isRevalidating = true;
+    m_resourceRequest = request;
     m_status = NotStarted;
 }
 
 void Resource::willFollowRedirect(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
 {
-    if (!m_revalidatingRequest.isNull())
+    if (m_isRevalidating)
         revalidationFailed();
 
     newRequest.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
     m_redirectChain.append(RedirectPair(newRequest, redirectResponse));
 }
 
 void Resource::setResponse(const ResourceResponse& response)
 {
     m_response = response;
     if (m_response.wasFetchedViaServiceWorker())
         m_cacheHandler = ServiceWorkerResponseCachedMetadataHandler::create(this, m_fetcherSecurityOrigin.get());
 }
 
 bool Resource::unlock()
 {
     if (!m_data)
         return false;
 
     if (!m_data->isLocked())
         return true;
 
-    if (!memoryCache()->contains(this) || hasClientsOrObservers() || !m_revalidatingRequest.isNull() || !m_loadFinishTime || !isSafeToUnlock())
+    if (!memoryCache()->contains(this) || hasClientsOrObservers() || !isLoaded() || !isSafeToUnlock())
         return false;
 
     if (RuntimeEnabledFeatures::doNotUnlockSharedBufferEnabled())
         return false;
 
     m_data->unlock();
     return true;
 }
 
 void Resource::responseReceived(const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle>)
 {
     m_responseTimestamp = currentTime();
     if (m_preloadDiscoveryTime) {
         int timeSinceDiscovery = static_cast<int>(1000 * (monotonicallyIncreasingTime() - m_preloadDiscoveryTime));
         DEFINE_STATIC_LOCAL(CustomCountHistogram, preloadDiscoveryToFirstByteHistogram, ("PreloadScanner.TTFB", 0, 10000, 50));
         preloadDiscoveryToFirstByteHistogram.count(timeSinceDiscovery);
     }
 
-    if (!m_revalidatingRequest.isNull()) {
+    if (m_isRevalidating) {
         if (response.httpStatusCode() == 304) {
             revalidationSucceeded(response);
             return;
         }
         revalidationFailed();
     }
     setResponse(response);
     String encoding = response.textEncodingName();
     if (!encoding.isNull())
         setEncoding(encoding);
 }
 
 void Resource::setSerializedCachedMetadata(const char* data, size_t size)
 {
-    ASSERT(m_revalidatingRequest.isNull());
+    DCHECK(!m_isRevalidating);
     ASSERT(!m_response.isNull());
     if (m_cacheHandler)
         m_cacheHandler->setSerializedCachedMetadata(data, size);
 }
 
 CachedMetadataHandler* Resource::cacheHandler()
 {
     return m_cacheHandler.get();
 }
 
@@ skipping 82 matching lines @@
         }
     }
     if (!hasClientsOrObservers())
         memoryCache()->makeLive(this);
 }
 
 void Resource::addClient(ResourceClient* client)
 {
     willAddClientOrObserver();
 
-    if (!m_revalidatingRequest.isNull()) {
+    if (m_isRevalidating) {
         m_clients.add(client);
         return;
     }
 
     // If we have existing data to send to the new client and the resource type supprts it, send it asynchronously.
     if (!m_response.isNull() && !shouldSendCachedDataSynchronouslyForType(getType()) && !m_needsSynchronousCacheHit) {
         m_clientsAwaitingCallback.add(client);
         ResourceCallback::callbackHandler().schedule(this);
         return;
     }
@@ skipping 200 matching lines @@
         // Entity headers should not be sent by servers when generating a 304
         // response; misconfigured servers send them anyway. We shouldn't allow
         // such headers to update the original request. We'll base this on the
         // list defined by RFC2616 7.1, with a few additions for extension headers
         // we care about.
         if (!shouldUpdateHeaderAfterRevalidation(header.key))
             continue;
         m_response.setHTTPHeaderField(header.key, header.value);
     }
 
-    m_resourceRequest = m_revalidatingRequest;
-    m_revalidatingRequest = ResourceRequest();
+    m_isRevalidating = false;
 }
 
 void Resource::revalidationFailed()
 {
-    m_resourceRequest = m_revalidatingRequest;
-    m_revalidatingRequest = ResourceRequest();
     SECURITY_CHECK(m_redirectChain.isEmpty());
     m_data.clear();
     m_cacheHandler.clear();
     destroyDecodedDataForFailedRevalidation();
+    m_isRevalidating = false;
 }
 
 bool Resource::canReuseRedirectChain()
 {
     for (auto& redirect : m_redirectChain) {
         if (!canUseResponse(redirect.m_redirectResponse, m_responseTimestamp))
             return false;
         if (redirect.m_request.cacheControlContainsNoCache() || redirect.m_request.cacheControlContainsNoStore())
             return false;
     }
@@ skipping 189 matching lines @@
     case Resource::Media:
         return "Media";
     case Resource::Manifest:
         return "Manifest";
     }
     ASSERT_NOT_REACHED();
     return "Unknown";
 }
 
 } // namespace blink