Make the uses of Resource::m_resourceRequest/m_response const if applicable

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
@@ skipping 320 matching lines @@
       m_integrityDisposition(ResourceIntegrityDisposition::NotChecked),
       m_options(options),
       m_responseTimestamp(currentTime()),
       m_cancelTimer(Platform::current()->mainThread()->getWebTaskRunner(),
                     this,
                     &Resource::cancelTimerFired),
       m_resourceRequest(request) {
   InstanceCounters::incrementCounter(InstanceCounters::ResourceCounter);
 
   // Currently we support the metadata caching only for HTTP family.
-  if (m_resourceRequest.url().protocolIsInHTTPFamily())
+  if (resourceRequest().url().protocolIsInHTTPFamily())
     m_cacheHandler = CachedMetadataHandlerImpl::create(this);
   MemoryCoordinator::instance().registerClient(this);
 }
 
 Resource::~Resource() {
   InstanceCounters::decrementCounter(InstanceCounters::ResourceCounter);
 }
 
 DEFINE_TRACE(Resource) {
   visitor->trace(m_loader);
@@ skipping 81 matching lines @@
   DCHECK(!m_isRevalidating);
   m_loadFinishTime = loadFinishTime;
   if (!errorOccurred())
     m_status = Cached;
   m_loader = nullptr;
   checkNotify();
 }
 
 AtomicString Resource::httpContentType() const {
   return extractMIMETypeFromMediaType(
-      m_response.httpHeaderField(HTTPNames::Content_Type).lower());
+      response().httpHeaderField(HTTPNames::Content_Type).lower());
 }
 
 bool Resource::passesAccessControlCheck(SecurityOrigin* securityOrigin) const {
   StoredCredentials storedCredentials =
       lastResourceRequest().allowStoredCredentials()
           ? AllowStoredCredentials
           : DoNotAllowStoredCredentials;
   CrossOriginAccessControl::AccessStatus status =
-      CrossOriginAccessControl::checkAccess(m_response, storedCredentials,
+      CrossOriginAccessControl::checkAccess(response(), storedCredentials,
                                             securityOrigin);
 
   return status == CrossOriginAccessControl::kAccessAllowed;
 }
 
 bool Resource::isEligibleForIntegrityCheck(
     SecurityOrigin* securityOrigin) const {
   return securityOrigin->canRequest(resourceRequest().url()) ||
          passesAccessControlCheck(securityOrigin);
 }
@@ skipping 23 matching lines @@
                            ? std::max(0., responseTimestamp - dateValue)
                            : 0;
   double ageValue = response.age();
   double correctedReceivedAge =
       std::isfinite(ageValue) ? std::max(apparentAge, ageValue) : apparentAge;
   double residentTime = currentTime() - responseTimestamp;
   return correctedReceivedAge + residentTime;
 }
 
 double Resource::currentAge() const {
-  return blink::currentAge(m_response, m_responseTimestamp);
+  return blink::currentAge(response(), m_responseTimestamp);
 }
 
-static double freshnessLifetime(ResourceResponse& response,
+static double freshnessLifetime(const ResourceResponse& response,
                                 double responseTimestamp) {
 #if !OS(ANDROID)
   // On desktop, local files should be reloaded in case they change.
   if (response.url().isLocalFile())
     return 0;
 #endif
 
   // Cache other non-http / non-filesystem resources liberally.
   if (!response.url().protocolIsInHTTPFamily() &&
       !response.url().protocolIs("filesystem"))
@@ skipping 10 matching lines @@
   if (std::isfinite(expiresValue))
     return expiresValue - creationTime;
   double lastModifiedValue = response.lastModified();
   if (std::isfinite(lastModifiedValue))
     return (creationTime - lastModifiedValue) * 0.1;
   // If no cache headers are present, the specification leaves the decision to
   // the UA. Other browsers seem to opt for 0.
   return 0;
 }
 
-double Resource::freshnessLifetime() {
-  return blink::freshnessLifetime(m_response, m_responseTimestamp);
+double Resource::freshnessLifetime() const {
+  return blink::freshnessLifetime(response(), m_responseTimestamp);
 }
 
-double Resource::stalenessLifetime() {
-  return m_response.cacheControlStaleWhileRevalidate();
+double Resource::stalenessLifetime() const {
+  return response().cacheControlStaleWhileRevalidate();
 }
 
-static bool canUseResponse(ResourceResponse& response,
+static bool canUseResponse(const ResourceResponse& response,
                            double responseTimestamp) {
   if (response.isNull())
     return false;
 
   // FIXME: Why isn't must-revalidate considered a reason we can't use the
   // response?
   if (response.cacheControlContainsNoCache() ||
       response.cacheControlContainsNoStore())
     return false;
 
@@ skipping 10 matching lines @@
     if (!hasMaxAge && !hasExpires)
       return false;
   }
 
   return currentAge(response, responseTimestamp) <=
          freshnessLifetime(response, responseTimestamp);
 }
 
 const ResourceRequest& Resource::lastResourceRequest() const {
   if (!m_redirectChain.size())
-    return m_resourceRequest;
+    return resourceRequest();
   return m_redirectChain.back().m_request;
 }
 
 void Resource::setRevalidatingRequest(const ResourceRequest& request) {
   SECURITY_CHECK(m_redirectChain.isEmpty());
   DCHECK(!request.isNull());
   CHECK(!m_isRevalidationStartForbidden);
   m_isRevalidating = true;
   m_resourceRequest = request;
   m_status = NotStarted;
 }
 
 bool Resource::willFollowRedirect(const ResourceRequest& newRequest,
                                   const ResourceResponse& redirectResponse) {
   if (m_isRevalidating)
     revalidationFailed();
   m_redirectChain.push_back(RedirectPair(newRequest, redirectResponse));
   return true;
 }
 
 void Resource::setResponse(const ResourceResponse& response) {
   m_response = response;
-  if (m_response.wasFetchedViaServiceWorker()) {
+  if (this->response().wasFetchedViaServiceWorker()) {
     m_cacheHandler = ServiceWorkerResponseCachedMetadataHandler::create(
         this, m_fetcherSecurityOrigin.get());
   }
 }
 
 void Resource::responseReceived(const ResourceResponse& response,
                                 std::unique_ptr<WebDataConsumerHandle>) {
   m_responseTimestamp = currentTime();
   if (m_preloadDiscoveryTime) {
     int timeSinceDiscovery = static_cast<int>(
@@ skipping 12 matching lines @@
     revalidationFailed();
   }
   setResponse(response);
   String encoding = response.textEncodingName();
   if (!encoding.isNull())
     setEncoding(encoding);
 }
 
 void Resource::setSerializedCachedMetadata(const char* data, size_t size) {
   DCHECK(!m_isRevalidating);
-  DCHECK(!m_response.isNull());
+  DCHECK(!response().isNull());
   if (m_cacheHandler)
     m_cacheHandler->setSerializedCachedMetadata(data, size);
 }
 
 CachedMetadataHandler* Resource::cacheHandler() {
   return m_cacheHandler.get();
 }
 
 String Resource::reasonNotDeletable() const {
   StringBuilder builder;
@@ skipping 86 matching lines @@
 
   willAddClientOrObserver(policy);
 
   if (m_isRevalidating) {
     m_clients.add(client);
     return;
   }
 
   // If an error has occurred or we have existing data to send to the new client
   // and the resource type supprts it, send it asynchronously.
-  if ((errorOccurred() || !m_response.isNull()) &&
+  if ((errorOccurred() || !response().isNull()) &&
       !typeNeedsSynchronousCacheHit(getType()) && !m_needsSynchronousCacheHit) {
     m_clientsAwaitingCallback.add(client);
     ResourceCallback::callbackHandler().schedule(this);
     return;
   }
 
   m_clients.add(client);
   didAddClient(client);
   return;
 }
@@ skipping 195 matching lines @@
 }
 
 void Resource::clearRangeRequestHeader() {
   m_resourceRequest.clearHTTPHeaderField("range");
 }
 
 void Resource::revalidationSucceeded(
     const ResourceResponse& validatingResponse) {
   SECURITY_CHECK(m_redirectChain.isEmpty());
   SECURITY_CHECK(equalIgnoringFragmentIdentifier(validatingResponse.url(),
-                                                 m_response.url()));
+                                                 response().url()));
   m_response.setResourceLoadTiming(validatingResponse.resourceLoadTiming());
 
   // RFC2616 10.3.5
   // Update cached headers from the 304 response
   const HTTPHeaderMap& newHeaders = validatingResponse.httpHeaderFields();
   for (const auto& header : newHeaders) {
     // 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_isRevalidating = false;
 }
 
 void Resource::revalidationFailed() {
   SECURITY_CHECK(m_redirectChain.isEmpty());
   clearData();
   m_cacheHandler.clear();
   destroyDecodedDataForFailedRevalidation();
   m_isRevalidating = false;
 }
 
-bool Resource::canReuseRedirectChain() {
+bool Resource::canReuseRedirectChain() const {
   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;
   }
   return true;
 }
 
 bool Resource::hasCacheControlNoStoreHeader() const {
-  return m_response.cacheControlContainsNoStore() ||
-         m_resourceRequest.cacheControlContainsNoStore();
+  return response().cacheControlContainsNoStore() ||
+         resourceRequest().cacheControlContainsNoStore();
 }
 
 bool Resource::hasVaryHeader() const {
-  return !m_response.httpHeaderField(HTTPNames::Vary).isNull();
+  return !response().httpHeaderField(HTTPNames::Vary).isNull();
 }
 
-bool Resource::mustRevalidateDueToCacheHeaders() {
-  return !canUseResponse(m_response, m_responseTimestamp) ||
-         m_resourceRequest.cacheControlContainsNoCache() ||
-         m_resourceRequest.cacheControlContainsNoStore();
+bool Resource::mustRevalidateDueToCacheHeaders() const {
+  return !canUseResponse(response(), m_responseTimestamp) ||
+         resourceRequest().cacheControlContainsNoCache() ||
+         resourceRequest().cacheControlContainsNoStore();
 }
 
-bool Resource::canUseCacheValidator() {
+bool Resource::canUseCacheValidator() const {
   if (isLoading() || errorOccurred())
     return false;
 
   if (hasCacheControlNoStoreHeader())
     return false;
 
   // Do not revalidate Resource with redirects. https://crbug.com/613971
   if (!redirectChain().isEmpty())
     return false;
 
-  return m_response.hasCacheValidatorFields() ||
-         m_resourceRequest.hasCacheValidatorFields();
+  return response().hasCacheValidatorFields() ||
+         resourceRequest().hasCacheValidatorFields();
 }
 
 size_t Resource::calculateOverheadSize() const {
   static const int kAverageClientsHashMapSize = 384;
-  return sizeof(Resource) + m_response.memoryUsage() +
+  return sizeof(Resource) + response().memoryUsage() +
          kAverageClientsHashMapSize +
-         m_resourceRequest.url().getString().length() * 2;
+         resourceRequest().url().getString().length() * 2;
 }
 
 void Resource::didChangePriority(ResourceLoadPriority loadPriority,
                                  int intraPriorityValue) {
   m_resourceRequest.setPriority(loadPriority, intraPriorityValue);
   if (m_loader)
     m_loader->didChangePriority(loadPriority, intraPriorityValue);
 }
 
 // TODO(toyoshim): Consider to generate automatically. https://crbug.com/675515.
@@ skipping 83 matching lines @@
     case Resource::Media:
     case Resource::Manifest:
     case Resource::Mock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink