Refactor MIME type related methods in XHR for readability

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 171 matching lines @@
 {
     ASSERT(m_responseTypeCode == ResponseTypeJSON);
 
     if (m_error || m_state != DONE)
         return ScriptString();
     return m_responseText;
 }
 
 void XMLHttpRequest::initResponseDocument()
 {
-    AtomicString mimeType = responseMIMEType();
+    AtomicString mimeType = finalMIMEType();

[sof, 2014/08/11 12:19:37]

Shouldn't this be finalMIMETypeWithFallback() for the benefit of setMimeType()
further down?

[tyoshino (SeeGerritForStatus), 2014/08/11 13:10:46]

Wow, good catch! Done.

     bool isHTML = equalIgnoringCase(mimeType, "text/html");
 
     // The W3C spec requires the final MIME type to be some valid XML type, or text/html.
     // If it is text/html, then the responseType of "document" must have been supplied explicitly.
     if ((m_response.isHTTP() && !responseIsXML() && !isHTML)
         || (isHTML && m_responseTypeCode == ResponseTypeDefault)
         || executionContext()->isWorkerGlobalScope()) {
         m_responseDocument = nullptr;
         return;
     }
@@ skipping 48 matching lines @@
         // When responseType is set to "blob", we redirect the downloaded data
         // to a file-handle directly in the browser process. We get the
         // file-path from the ResourceResponse directly instead of copying the
         // bytes between the browser and the renderer.
         OwnPtr<BlobData> blobData = BlobData::create();
         String filePath = m_response.downloadedFilePath();
         // If we errored out or got no data, we still return a blob, just an
         // empty one.
         if (!filePath.isEmpty() && m_downloadedBlobLength) {
             blobData->appendFile(filePath);
-            blobData->setContentType(responseMIMEType()); // responseMIMEType defaults to text/xml which may be incorrect.
+            // FIXME: finalMIMETypeWithFallback() defaults to text/xml which
+            // may be incorrect. Replace it with finalMIMEType() after
+            // compatibility investigation.
+            blobData->setContentType(finalMIMETypeWithFallback());
         }
         m_responseBlob = Blob::create(BlobDataHandle::create(blobData.release(), m_downloadedBlobLength));
     }
 
     return m_responseBlob.get();
 }
 
 ArrayBuffer* XMLHttpRequest::responseArrayBuffer()
 {
     ASSERT(m_responseTypeCode == ResponseTypeArrayBuffer);
@@ skipping 599 matching lines @@
         ASSERT(!m_loader);
         handleRequestError(0, EventTypeNames::abort, receivedLength, expectedLength);
     }
     m_state = UNSENT;
 }
 
 void XMLHttpRequest::clearVariablesForLoading()
 {
     m_decoder.clear();
 
-    m_responseEncoding = String();
+    m_finalCharset = String();
 }
 
 bool XMLHttpRequest::internalAbort()
 {
     m_error = true;
 
     clearVariablesForLoading();
 
     InspectorInstrumentation::didFailXHRLoading(executionContext(), this, this);
 
@@ skipping 130 matching lines @@
     // Note: The below event dispatch may be called while |hasPendingActivity() == false|,
     // when |handleRequestError| is called after |internalAbort()|.
     // This is safe, however, as |this| will be kept alive from a strong ref |Event::m_target|.
     dispatchProgressEvent(EventTypeNames::progress, receivedLength, expectedLength);
     dispatchProgressEvent(type, receivedLength, expectedLength);
     dispatchProgressEvent(EventTypeNames::loadend, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::overrideMimeType(const AtomicString& override)
 {
+    // FIXME: This method must throw an InvalidStateError exception when the
+    // XHR is in the LOADING or DONE state. http://crbug.com/402375
+
     m_mimeTypeOverride = override;
 }
 
 void XMLHttpRequest::setRequestHeader(const AtomicString& name, const AtomicString& value, ExceptionState& exceptionState)
 {
     if (m_state != OPENED || m_loader) {
         exceptionState.throwDOMException(InvalidStateError, "The object's state must be OPENED.");
         return;
     }
 
@@ skipping 76 matching lines @@
     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 nullAtom;
     }
     return m_response.httpHeaderField(name);
 }
 
-AtomicString XMLHttpRequest::responseMIMEType() const
+AtomicString XMLHttpRequest::finalMIMEType() const
 {
-    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 = AtomicString("text/xml", AtomicString::ConstructFromLiteral);
+    AtomicString overriddenType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
+    if (!overriddenType.isEmpty())
+        return overriddenType;
 
-    return mimeType;
+    if (m_response.isHTTP())
+        return extractMIMETypeFromMediaType(m_response.httpHeaderField("Content-Type"));
+
+    return m_response.mimeType();
+}
+
+AtomicString XMLHttpRequest::finalMIMETypeWithFallback() const
+{
+    AtomicString finalType = finalMIMEType();
+    if (!finalType.isEmpty())
+        return finalType;
+
+    // FIXME: This fallback is not specified in the final MIME type algorithm
+    // of the XHR spec. Move this to more appropriate place.
+    return AtomicString("text/xml", AtomicString::ConstructFromLiteral);
 }
 
 bool XMLHttpRequest::responseIsXML() const
 {
-    return DOMImplementation::isXMLMIMEType(responseMIMEType());
+    return DOMImplementation::isXMLMIMEType(finalMIMETypeWithFallback());
 }
 
 int XMLHttpRequest::status() const
 {
     if (m_state == UNSENT || m_state == OPENED || m_error)
         return 0;
 
     if (m_response.httpStatusCode())
         return m_response.httpStatusCode();
 
@@ skipping 86 matching lines @@
     }
 }
 
 void XMLHttpRequest::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
 {
     WTF_LOG(Network, "XMLHttpRequest %p didReceiveResponse(%lu)", this, identifier);
 
     m_response = response;
     if (!m_mimeTypeOverride.isEmpty()) {
         m_response.setHTTPHeaderField("Content-Type", m_mimeTypeOverride);
-        m_responseEncoding = extractCharsetFromMediaType(m_mimeTypeOverride);
+        m_finalCharset = extractCharsetFromMediaType(m_mimeTypeOverride);
     }
 
-    if (m_responseEncoding.isEmpty())
-        m_responseEncoding = response.textEncodingName();
+    if (m_finalCharset.isEmpty())
+        m_finalCharset = response.textEncodingName();
 }
 
 PassOwnPtr<TextResourceDecoder> XMLHttpRequest::createDecoder() const
 {
     if (m_responseTypeCode == ResponseTypeJSON)
         return TextResourceDecoder::create("application/json", "UTF-8");
 
-    if (!m_responseEncoding.isEmpty())
-        return TextResourceDecoder::create("text/plain", m_responseEncoding);
+    if (!m_finalCharset.isEmpty())
+        return TextResourceDecoder::create("text/plain", m_finalCharset);
 
     // allow TextResourceDecoder to look inside the m_response if it's XML or HTML
     if (responseIsXML()) {
         OwnPtr<TextResourceDecoder> decoder = TextResourceDecoder::create("application/xml");
         // Don't stop on encoding errors, unlike it is done for other kinds
         // of XML resources. This matches the behavior of previous WebKit
         // versions, Firefox and Opera.
         decoder->useLenientXMLDecoding();
 
         return decoder.release();
     }
 
-    if (equalIgnoringCase(responseMIMEType(), "text/html"))
+    if (equalIgnoringCase(finalMIMEType(), "text/html"))
         return TextResourceDecoder::create("text/html", "UTF-8");
 
     return TextResourceDecoder::create("text/plain", "UTF-8");
 }
 
 void XMLHttpRequest::didReceiveData(const char* data, int len)
 {
     ASSERT(m_responseTypeCode != ResponseTypeBlob);
 
     if (m_error)
@@ skipping 14 matching lines @@
             m_decoder = createDecoder();
 
         m_responseText = m_responseText.concatenateWith(m_decoder->decode(data, len));
     } else if (m_responseTypeCode == ResponseTypeArrayBuffer) {
         // Buffer binary data.
         if (!m_binaryResponseBuilder)
             m_binaryResponseBuilder = SharedBuffer::create();
         m_binaryResponseBuilder->append(data, len);
     } else if (m_responseTypeCode == ResponseTypeLegacyStream) {
         if (!m_responseStream)
-            m_responseStream = Stream::create(executionContext(), responseMIMEType());
+            m_responseStream = Stream::create(executionContext(), finalMIMEType());
         m_responseStream->addData(data, len);
     }
 
     if (m_error)
         return;
 
     trackProgress(len);
 }
 
 void XMLHttpRequest::didDownloadData(int dataLength)
@@ skipping 77 matching lines @@
 {
     visitor->trace(m_responseBlob);
     visitor->trace(m_responseStream);
     visitor->trace(m_responseDocument);
     visitor->trace(m_progressEventThrottle);
     visitor->trace(m_upload);
     XMLHttpRequestEventTarget::trace(visitor);
 }
 
 } // namespace blink