Update HTTPHeaderMap wrappers to use AtomicString type for header values

Source/core/xml/XMLHttpRequest.cpp

 /*
  *  Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
  *  Copyright (C) 2012 Intel Corporation
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 443 matching lines @@
     m_includeCredentials = value;
 }
 
 bool XMLHttpRequest::isAllowedHTTPMethod(const String& method)
 {
     return !equalIgnoringCase(method, "TRACE")
         && !equalIgnoringCase(method, "TRACK")
         && !equalIgnoringCase(method, "CONNECT");
 }
 
-String XMLHttpRequest::uppercaseKnownHTTPMethod(const String& method)
+AtomicString XMLHttpRequest::uppercaseKnownHTTPMethod(const AtomicString& method)
 {
     const char* const methods[] = {
         "COPY",
         "DELETE",
         "GET",
         "HEAD",
         "INDEX",
         "LOCK",
         "M-POST",
         "MKCOL",
@@ skipping 15 matching lines @@
     return method;
 }
 
 bool XMLHttpRequest::isAllowedHTTPHeader(const String& name)
 {
     initializeXMLHttpRequestStaticData();
     return !staticData->m_forbiddenRequestHeaders.contains(name) && !name.startsWith(staticData->m_proxyHeaderPrefix, false)
         && !name.startsWith(staticData->m_secHeaderPrefix, false);
 }
 
-void XMLHttpRequest::open(const String& method, const KURL& url, ExceptionState& exceptionState)
+void XMLHttpRequest::open(const AtomicString& method, const KURL& url, ExceptionState& exceptionState)
 {
     open(method, url, true, exceptionState);
 }
 
-void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionState& exceptionState)
+void XMLHttpRequest::open(const AtomicString& method, const KURL& url, bool async, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p open('%s', '%s', %d)", this, method.utf8().data(), url.elidedString().utf8().data(), async);
+    WTF_LOG(Network, "XMLHttpRequest %p open('%s', '%s', %d)", this, method.string().utf8().data(), url.elidedString().utf8().data(), async);
 
     if (!internalAbort())
         return;
 
     State previousState = m_state;
     m_state = UNSENT;
     m_error = false;
     m_uploadComplete = false;
 
     // clear stuff from possible previous load
@@ skipping 49 matching lines @@
     ASSERT(!m_loader);
 
     // Check previous state to avoid dispatching readyState event
     // when calling open several times in a row.
     if (previousState != OPENED)
         changeState(OPENED);
     else
         m_state = OPENED;
 }
 
-void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, ExceptionState& exceptionState)
+void XMLHttpRequest::open(const AtomicString& method, const KURL& url, bool async, const String& user, ExceptionState& exceptionState)
 {
     KURL urlWithCredentials(url);
     urlWithCredentials.setUser(user);
 
     open(method, urlWithCredentials, async, exceptionState);
 }
 
-void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, const String& password, ExceptionState& exceptionState)
+void XMLHttpRequest::open(const AtomicString& method, const KURL& url, bool async, const String& user, const String& password, ExceptionState& exceptionState)
 {
     KURL urlWithCredentials(url);
     urlWithCredentials.setUser(user);
     urlWithCredentials.setPass(password);
 
     open(method, urlWithCredentials, async, exceptionState);
 }
 
 bool XMLHttpRequest::initSend(ExceptionState& exceptionState)
 {
@@ skipping 54 matching lines @@
 
     if (!initSend(exceptionState))
         return;
 
     if (!body.isNull() && areMethodAndURLValidForSend()) {
         String contentType = getRequestHeader("Content-Type");
         if (contentType.isEmpty()) {
             setRequestHeaderInternal("Content-Type", "text/plain;charset=UTF-8");
         } else {
             replaceCharsetInMediaType(contentType, "UTF-8");
-            m_requestHeaders.set("Content-Type", contentType);
+            m_requestHeaders.set("Content-Type", AtomicString(contentType));
         }
 
         m_requestEntityBody = FormData::create(UTF8Encoding().encode(body, WTF::EntitiesForUnencodables));
         if (m_upload)
             m_requestEntityBody->setAlwaysStream(true);
     }
 
     createRequest(exceptionState);
 }
 
 void XMLHttpRequest::send(Blob* body, ExceptionState& exceptionState)
 {
     WTF_LOG(Network, "XMLHttpRequest %p send() Blob '%s'", this, body->uuid().utf8().data());
 
     if (!initSend(exceptionState))
         return;
 
     if (areMethodAndURLValidForSend()) {
         const String& contentType = getRequestHeader("Content-Type");
         if (contentType.isEmpty()) {
             const String& blobType = body->type();
             if (!blobType.isEmpty() && isValidContentType(blobType))
-                setRequestHeaderInternal("Content-Type", blobType);
+                setRequestHeaderInternal("Content-Type", AtomicString(blobType));
             else {
                 // From FileAPI spec, whenever media type cannot be determined, empty string must be returned.
                 setRequestHeaderInternal("Content-Type", "");
             }
         }
 
         // FIXME: add support for uploading bundles.
         m_requestEntityBody = FormData::create();
         if (body->hasBackingFile())
             m_requestEntityBody->appendFile(toFile(body)->path());
         else
             m_requestEntityBody->appendBlob(body->uuid(), body->blobDataHandle());
     }
 
     createRequest(exceptionState);
 }
 
 void XMLHttpRequest::send(DOMFormData* body, ExceptionState& exceptionState)
 {
     WTF_LOG(Network, "XMLHttpRequest %p send() DOMFormData %p", this, body);
 
     if (!initSend(exceptionState))
         return;
 
     if (areMethodAndURLValidForSend()) {
         m_requestEntityBody = body->createMultiPartFormData(body->encoding());
 
-        String contentType = getRequestHeader("Content-Type");
-        if (contentType.isEmpty()) {
-            contentType = String("multipart/form-data; boundary=") + m_requestEntityBody->boundary().data();
+        if (getRequestHeader("Content-Type").isEmpty()) {
+            AtomicString contentType = AtomicString("multipart/form-data; boundary=", AtomicString::ConstructFromLiteral) + m_requestEntityBody->boundary().data();
             setRequestHeaderInternal("Content-Type", contentType);
         }
     }
 
     createRequest(exceptionState);
 }
 
 void XMLHttpRequest::send(ArrayBuffer* body, ExceptionState& exceptionState)
 {
     WTF_LOG(Network, "XMLHttpRequest %p send() ArrayBuffer %p", this, body);
@@ skipping 317 matching lines @@
 void XMLHttpRequest::dropProtectionSoon()
 {
     m_dropProtectionRunner.runAsync();
 }
 
 void XMLHttpRequest::dropProtection()
 {
     unsetPendingActivity(this);
 }
 
-void XMLHttpRequest::overrideMimeType(const String& override)
+void XMLHttpRequest::overrideMimeType(const AtomicString& override)
 {
     m_mimeTypeOverride = override;
 }
 
-void XMLHttpRequest::setRequestHeader(const AtomicString& name, const String& value, ExceptionState& exceptionState)
+void XMLHttpRequest::setRequestHeader(const AtomicString& name, const AtomicString& value, ExceptionState& exceptionState)
 {
     if (m_state != OPENED || m_loader) {
         exceptionState.throwDOMException(InvalidStateError, ExceptionMessages::failedToExecute("setRequestHeader", "XMLHttpRequest", "The object's state must be OPENED."));
         return;
     }
 
     if (!isValidHTTPToken(name)) {
         exceptionState.throwDOMException(SyntaxError, ExceptionMessages::failedToExecute("setRequestHeader", "XMLHttpRequest", "'" + name + "' is not a valid HTTP header field name."));
         return;
     }
 
     if (!isValidHTTPHeaderValue(value)) {
         exceptionState.throwDOMException(SyntaxError, ExceptionMessages::failedToExecute("setRequestHeader", "XMLHttpRequest", "'" + value + "' is not a valid HTTP header field value."));
         return;
     }
 
     // No script (privileged or not) can set unsafe headers.
     if (!isAllowedHTTPHeader(name)) {
         logConsoleError(executionContext(), "Refused to set unsafe header \"" + name + "\"");
         return;
     }
 
     setRequestHeaderInternal(name, value);
 }
 
-void XMLHttpRequest::setRequestHeaderInternal(const AtomicString& name, const String& value)
+void XMLHttpRequest::setRequestHeaderInternal(const AtomicString& name, const AtomicString& value)
 {
     HTTPHeaderMap::AddResult result = m_requestHeaders.add(name, value);
     if (!result.isNewEntry)
         result.iterator->value = result.iterator->value + ", " + value;
 }
 
-String XMLHttpRequest::getRequestHeader(const AtomicString& name) const
+AtomicString XMLHttpRequest::getRequestHeader(const AtomicString& name) const
 {
     return m_requestHeaders.get(name);
 }
 
 String XMLHttpRequest::getAllResponseHeaders(ExceptionState& exceptionState) const
 {
     if (m_state < HEADERS_RECEIVED || m_error)
         return "";
 
     StringBuilder stringBuilder;
@@ skipping 18 matching lines @@
         stringBuilder.append(':');
         stringBuilder.append(' ');
         stringBuilder.append(it->value);
         stringBuilder.append('\r');
         stringBuilder.append('\n');
     }
 
     return stringBuilder.toString();
 }
 
-String XMLHttpRequest::getResponseHeader(const AtomicString& name, ExceptionState& exceptionState) const
+AtomicString XMLHttpRequest::getResponseHeader(const AtomicString& name, ExceptionState& exceptionState) const
 {
     if (m_state < HEADERS_RECEIVED || m_error)
-        return String();
+        return nullAtom;
 
     // See comment in getAllResponseHeaders above.
     if (isSetCookieHeader(name) && !securityOrigin()->canLoadLocalResources()) {
         logConsoleError(executionContext(), "Refused to get unsafe header \"" + name + "\"");
-        return String();
+        return nullAtom;
     }
 
     HTTPHeaderSet accessControlExposeHeaderSet;
     parseAccessControlExposeHeadersAllowList(m_response.httpHeaderField("Access-Control-Expose-Headers"), accessControlExposeHeaderSet);
 
     if (!m_sameOriginRequest && !isOnAccessControlResponseHeaderWhitelist(name) && !accessControlExposeHeaderSet.contains(name)) {
         logConsoleError(executionContext(), "Refused to get unsafe header \"" + name + "\"");
-        return String();
+        return nullAtom;
     }
     return m_response.httpHeaderField(name);
 }
 
-String XMLHttpRequest::responseMIMEType() const
+AtomicString XMLHttpRequest::responseMIMEType() const
 {
-    String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
+    AtomicString mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
     if (mimeType.isEmpty()) {
         if (m_response.isHTTP())
             mimeType = extractMIMETypeFromMediaType(m_response.httpHeaderField("Content-Type"));
         else
             mimeType = m_response.mimeType();
     }
     if (mimeType.isEmpty())
-        mimeType = "text/xml";
+        mimeType = AtomicString("text/xml", AtomicString::ConstructFromLiteral);
 
     return mimeType;
 }
 
 bool XMLHttpRequest::responseIsXML() const
 {
     // FIXME: Remove the lower() call when DOMImplementation.isXMLMIMEType() is modified
     //        to do case insensitive MIME type matching.
     return DOMImplementation::isXMLMIMEType(responseMIMEType().lower());
 }
@@ skipping 224 matching lines @@
 {
     return EventTargetNames::XMLHttpRequest;
 }
 
 ExecutionContext* XMLHttpRequest::executionContext() const
 {
     return ActiveDOMObject::executionContext();
 }
 
 } // namespace WebCore