Have HashMap<KeyType, AtomicString>::get() return a const reference

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 249 matching lines @@
 const AtomicString& ResourceResponse::httpStatusText() const
 {
     return m_httpStatusText;
 }
 
 void ResourceResponse::setHTTPStatusText(const AtomicString& statusText)
 {
     m_httpStatusText = statusText;
 }
 
-AtomicString ResourceResponse::httpHeaderField(const AtomicString& name) const
+const AtomicString& ResourceResponse::httpHeaderField(const AtomicString& name) const
 {
     return m_httpHeaderFields.get(name);
 }
 
 const AtomicString& ResourceResponse::httpHeaderField(const char* name) const
 {
     return m_httpHeaderFields.get(name);
 }
 
 void ResourceResponse::updateHeaderParsedState(const AtomicString& name)
@@ skipping 52 matching lines @@
     m_cacheControlContainsMustRevalidate = false;
     m_cacheControlContainsNoCache = false;
     m_cacheControlMaxAge = std::numeric_limits<double>::quiet_NaN();
 
     DEFINE_STATIC_LOCAL(const AtomicString, cacheControlString, ("cache-control", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, noCacheDirective, ("no-cache", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, noStoreDirective, ("no-store", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, mustRevalidateDirective, ("must-revalidate", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, maxAgeDirective, ("max-age", AtomicString::ConstructFromLiteral));
 
-    AtomicString cacheControlValue = m_httpHeaderFields.get(cacheControlString);
+    const AtomicString& cacheControlValue = m_httpHeaderFields.get(cacheControlString);
     if (!cacheControlValue.isEmpty()) {
         Vector<pair<String, String> > directives;
         parseCacheHeader(cacheControlValue, directives);
 
         size_t directivesSize = directives.size();
         for (size_t i = 0; i < directivesSize; ++i) {
             // RFC2616 14.9.1: A no-cache directive with a value is only meaningful for proxy caches.
             // It should be ignored by a browser level cache.
             if (equalIgnoringCase(directives[i].first, noCacheDirective) && directives[i].second.isEmpty())
                 m_cacheControlContainsNoCache = true;
@@ skipping 12 matching lines @@
                     m_cacheControlMaxAge = maxAge;
             }
         }
     }
 
     if (!m_cacheControlContainsNoCache) {
         // Handle Pragma: no-cache
         // This is deprecated and equivalent to Cache-control: no-cache
         // Don't bother tokenizing the value, it is not important
         DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma", AtomicString::ConstructFromLiteral));
-        String pragmaValue = m_httpHeaderFields.get(pragmaHeader);
+        const AtomicString& pragmaValue = m_httpHeaderFields.get(pragmaHeader);
 
         m_cacheControlContainsNoCache = pragmaValue.lower().contains(noCacheDirective);
     }
 }
 
 bool ResourceResponse::cacheControlContainsNoCache() const
 {
     if (!m_haveParsedCacheControlHeader)
         parseCacheControlDirectives();
     return m_cacheControlContainsNoCache;
@@ skipping 22 matching lines @@
 
 double ResourceResponse::cacheControlMaxAge() const
 {
     if (!m_haveParsedCacheControlHeader)
         parseCacheControlDirectives();
     return m_cacheControlMaxAge;
 }
 
 static double parseDateValueInHeader(const HTTPHeaderMap& headers, const AtomicString& headerName)
 {
-    String headerValue = headers.get(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", AtomicString::ConstructFromLiteral));
         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", AtomicString::ConstructFromLiteral));
-        String headerValue = m_httpHeaderFields.get(headerName);
+        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
@@ skipping 217 matching lines @@
             pos += nextCommaPosition - pos + 1;
         } else {
             // Add last directive to map with empty string as value
             result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), ""));
             return;
         }
     }
 }
 
 }