Stop using DEFINE_STATIC_LOCAL in ResourceResponse.cpp.

third_party/WebKit/Source/platform/network/ResourceResponse.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 27 matching lines @@
 template <typename Interface>
 Vector<Interface> isolatedCopy(const Vector<Interface>& src) {
   Vector<Interface> result;
   result.reserveCapacity(src.size());
   for (const auto& timestamp : src) {
     result.push_back(timestamp.isolatedCopy());
   }
   return result;
 }
 
+static const char cacheControlHeader[] = "cache-control";
+static const char pragmaHeader[] = "pragma";
+
 }  // namespace
 
 ResourceResponse::SignedCertificateTimestamp::SignedCertificateTimestamp(
     const blink::WebURLResponse::SignedCertificateTimestamp& sct)
     : m_status(sct.status),
       m_origin(sct.origin),
       m_logDescription(sct.logDescription),
       m_logId(sct.logId),
       m_timestamp(sct.timestamp),
       m_hashAlgorithm(sct.hashAlgorithm),
@@ skipping 292 matching lines @@
 
 void ResourceResponse::setHTTPStatusText(const AtomicString& statusText) {
   m_httpStatusText = statusText;
 }
 
 const AtomicString& ResourceResponse::httpHeaderField(
     const AtomicString& name) const {
   return m_httpHeaderFields.get(name);
 }
 
-static const AtomicString& cacheControlHeaderString() {
-  DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader,
-                      ("cache-control"));
-  return cacheControlHeader;
-}
-
-static const AtomicString& pragmaHeaderString() {
-  DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
-  return pragmaHeader;
-}
-
 void ResourceResponse::updateHeaderParsedState(const AtomicString& name) {
-  DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age"));
-  DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date"));
-  DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires"));
-  DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader,
-                      ("last-modified"));
+  static const char ageHeader[] = "age";
+  static const char dateHeader[] = "date";
+  static const char expiresHeader[] = "expires";
+  static const char lastModifiedHeader[] = "last-modified";
 
   if (equalIgnoringCase(name, ageHeader))
     m_haveParsedAgeHeader = false;
-  else if (equalIgnoringCase(name, cacheControlHeaderString()) ||
-           equalIgnoringCase(name, pragmaHeaderString()))
+  else if (equalIgnoringCase(name, cacheControlHeader) ||
+           equalIgnoringCase(name, pragmaHeader))
     m_cacheControlHeader = CacheControlHeader();
   else if (equalIgnoringCase(name, dateHeader))
     m_haveParsedDateHeader = false;
   else if (equalIgnoringCase(name, expiresHeader))
     m_haveParsedExpiresHeader = false;
   else if (equalIgnoringCase(name, lastModifiedHeader))
     m_haveParsedLastModifiedHeader = false;
 }
 
 void ResourceResponse::setSecurityDetails(
@@ skipping 41 matching lines @@
 
 void ResourceResponse::clearHTTPHeaderField(const AtomicString& name) {
   m_httpHeaderFields.remove(name);
 }
 
 const HTTPHeaderMap& ResourceResponse::httpHeaderFields() const {
   return m_httpHeaderFields;
 }
 
 bool ResourceResponse::cacheControlContainsNoCache() const {
-  if (!m_cacheControlHeader.parsed)
-    m_cacheControlHeader = parseCacheControlDirectives(
-        m_httpHeaderFields.get(cacheControlHeaderString()),
-        m_httpHeaderFields.get(pragmaHeaderString()));
+  if (!m_cacheControlHeader.parsed) {
+    m_cacheControlHeader =
+        parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeader),
+                                    m_httpHeaderFields.get(pragmaHeader));
+  }
   return m_cacheControlHeader.containsNoCache;
 }
 
 bool ResourceResponse::cacheControlContainsNoStore() const {
-  if (!m_cacheControlHeader.parsed)
-    m_cacheControlHeader = parseCacheControlDirectives(
-        m_httpHeaderFields.get(cacheControlHeaderString()),
-        m_httpHeaderFields.get(pragmaHeaderString()));
+  if (!m_cacheControlHeader.parsed) {
+    m_cacheControlHeader =
+        parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeader),
+                                    m_httpHeaderFields.get(pragmaHeader));
+  }
   return m_cacheControlHeader.containsNoStore;
 }
 
 bool ResourceResponse::cacheControlContainsMustRevalidate() const {
-  if (!m_cacheControlHeader.parsed)
-    m_cacheControlHeader = parseCacheControlDirectives(
-        m_httpHeaderFields.get(cacheControlHeaderString()),
-        m_httpHeaderFields.get(pragmaHeaderString()));
+  if (!m_cacheControlHeader.parsed) {
+    m_cacheControlHeader =
+        parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeader),
+                                    m_httpHeaderFields.get(pragmaHeader));
+  }
   return m_cacheControlHeader.containsMustRevalidate;
 }
 
 bool ResourceResponse::hasCacheValidatorFields() const {
-  DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader,
-                      ("last-modified"));
-  DEFINE_STATIC_LOCAL(const AtomicString, eTagHeader, ("etag"));
+  static const char lastModifiedHeader[] = "last-modified";
+  static const char eTagHeader[] = "etag";
   return !m_httpHeaderFields.get(lastModifiedHeader).isEmpty() ||
          !m_httpHeaderFields.get(eTagHeader).isEmpty();
 }
 
 double ResourceResponse::cacheControlMaxAge() const {
-  if (!m_cacheControlHeader.parsed)
-    m_cacheControlHeader = parseCacheControlDirectives(
-        m_httpHeaderFields.get(cacheControlHeaderString()),
-        m_httpHeaderFields.get(pragmaHeaderString()));
+  if (!m_cacheControlHeader.parsed) {
+    m_cacheControlHeader =
+        parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeader),
+                                    m_httpHeaderFields.get(pragmaHeader));
+  }
   return m_cacheControlHeader.maxAge;
 }
 
 double ResourceResponse::cacheControlStaleWhileRevalidate() const {
-  if (!m_cacheControlHeader.parsed)
-    m_cacheControlHeader = parseCacheControlDirectives(
-        m_httpHeaderFields.get(cacheControlHeaderString()),
-        m_httpHeaderFields.get(pragmaHeaderString()));
+  if (!m_cacheControlHeader.parsed) {
+    m_cacheControlHeader =
+        parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeader),
+                                    m_httpHeaderFields.get(pragmaHeader));
+  }
   return m_cacheControlHeader.staleWhileRevalidate;
 }
 
 static double parseDateValueInHeader(const HTTPHeaderMap& headers,
                                      const AtomicString& headerName) {
   const AtomicString& headerValue = headers.get(headerName);
   if (headerValue.isEmpty())
     return std::numeric_limits<double>::quiet_NaN();
   // This handles all date formats required by RFC2616:
   // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
   // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
   // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
   double dateInMilliseconds = parseDate(headerValue);
   if (!std::isfinite(dateInMilliseconds))
     return std::numeric_limits<double>::quiet_NaN();
   return dateInMilliseconds / 1000;
 }
 
 double ResourceResponse::date() const {
   if (!m_haveParsedDateHeader) {
-    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date"));
+    static const char headerName[] = "date";
     m_date = parseDateValueInHeader(m_httpHeaderFields, headerName);
     m_haveParsedDateHeader = true;
   }
   return m_date;
 }
 
 double ResourceResponse::age() const {
   if (!m_haveParsedAgeHeader) {
-    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age"));
+    static const char headerName[] = "age";
     const AtomicString& headerValue = m_httpHeaderFields.get(headerName);
     bool ok;
     m_age = headerValue.toDouble(&ok);
     if (!ok)
       m_age = std::numeric_limits<double>::quiet_NaN();
     m_haveParsedAgeHeader = true;
   }
   return m_age;
 }
 
 double ResourceResponse::expires() const {
   if (!m_haveParsedExpiresHeader) {
-    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires"));
+    static const char headerName[] = "expires";
     m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName);
     m_haveParsedExpiresHeader = true;
   }
   return m_expires;
 }
 
 double ResourceResponse::lastModified() const {
   if (!m_haveParsedLastModifiedHeader) {
-    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified"));
+    static const char headerName[] = "last-modified";
     m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName);
     m_haveParsedLastModifiedHeader = true;
   }
   return m_lastModified;
 }
 
 bool ResourceResponse::isAttachment() const {
-  DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition"));
+  static const char headerName[] = "content-disposition";
+  static const char attachmentString[] = "attachment";
   String value = m_httpHeaderFields.get(headerName);
   size_t loc = value.find(';');
   if (loc != kNotFound)
     value = value.left(loc);
   value = value.stripWhiteSpace();
-  DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment"));
   return equalIgnoringCase(value, attachmentString);
 }
 
 void ResourceResponse::setLastModifiedDate(time_t lastModifiedDate) {
   m_lastModifiedDate = lastModifiedDate;
 }
 
 time_t ResourceResponse::lastModifiedDate() const {
   return m_lastModifiedDate;
 }
@@ skipping 102 matching lines @@
   if (a.resourceLoadTiming() != b.resourceLoadTiming())
     return false;
   if (a.encodedBodyLength() != b.encodedBodyLength())
     return false;
   if (a.decodedBodyLength() != b.decodedBodyLength())
     return false;
   return true;
 }
 
 }  // namespace blink