Rename Blink constants generated from IDL files.

third_party/WebKit/Source/core/xmlhttprequest/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 190 matching lines @@
     XMLHttpRequest* xmlHttpRequest = new XMLHttpRequest(context, nullptr);
     xmlHttpRequest->suspendIfNeeded();
 
     return xmlHttpRequest;
 }
 
 XMLHttpRequest::XMLHttpRequest(ExecutionContext* context, PassRefPtr<SecurityOrigin> isolatedWorldSecurityOrigin)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
     , m_timeoutMilliseconds(0)
-    , m_state(UNSENT)
+    , m_state(kUnsent)
     , m_lengthDownloadedToFile(0)
     , m_receivedLength(0)
     , m_exceptionCode(0)
     , m_progressEventThrottle(XMLHttpRequestProgressEventThrottle::create(this))
     , m_responseTypeCode(ResponseTypeDefault)
     , m_isolatedWorldSecurityOrigin(isolatedWorldSecurityOrigin)
     , m_eventDispatchRecursionLevel(0)
     , m_async(true)
     , m_includeCredentials(false)
     , m_parsedResponse(false)
@@ skipping 25 matching lines @@
 {
     return m_state;
 }
 
 ScriptString XMLHttpRequest::responseText(ExceptionState& exceptionState)
 {
     if (m_responseTypeCode != ResponseTypeDefault && m_responseTypeCode != ResponseTypeText) {
         exceptionState.throwDOMException(InvalidStateError, "The value is only accessible if the object's 'responseType' is '' or 'text' (was '" + responseType() + "').");
         return ScriptString();
     }
-    if (m_error || (m_state != LOADING && m_state != DONE))
+    if (m_error || (m_state != kLoading && m_state != kDone))
         return ScriptString();
     return m_responseText;
 }
 
 ScriptString XMLHttpRequest::responseJSONSource()
 {
     ASSERT(m_responseTypeCode == ResponseTypeJSON);
 
-    if (m_error || m_state != DONE)
+    if (m_error || m_state != kDone)
         return ScriptString();
     return m_responseText;
 }
 
 void XMLHttpRequest::initResponseDocument()
 {
     // 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.
     bool isHTML = responseIsHTML();
     if ((m_response.isHTTP() && !responseIsXML() && !isHTML)
@@ skipping 15 matching lines @@
     m_responseDocument->setMimeType(finalResponseMIMETypeWithFallback());
 }
 
 Document* XMLHttpRequest::responseXML(ExceptionState& exceptionState)
 {
     if (m_responseTypeCode != ResponseTypeDefault && m_responseTypeCode != ResponseTypeDocument) {
         exceptionState.throwDOMException(InvalidStateError, "The value is only accessible if the object's 'responseType' is '' or 'document' (was '" + responseType() + "').");
         return nullptr;
     }
 
-    if (m_error || m_state != DONE)
+    if (m_error || m_state != kDone)
         return nullptr;
 
     if (!m_parsedResponse) {
         initResponseDocument();
         if (!m_responseDocument)
             return nullptr;
 
         m_responseDocument->setContent(m_responseText.flattenToString());
         if (!m_responseDocument->wellFormed())
             m_responseDocument = nullptr;
 
         m_parsedResponse = true;
     }
 
     return m_responseDocument.get();
 }
 
 Blob* XMLHttpRequest::responseBlob()
 {
     ASSERT(m_responseTypeCode == ResponseTypeBlob);
 
-    // We always return null before DONE.
-    if (m_error || m_state != DONE)
+    // We always return null before kDone.
+    if (m_error || m_state != kDone)
         return nullptr;
 
     if (!m_responseBlob) {
         if (m_downloadingToFile) {
             ASSERT(!m_binaryResponseBuilder);
 
             // 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.
@@ skipping 11 matching lines @@
         }
     }
 
     return m_responseBlob;
 }
 
 DOMArrayBuffer* XMLHttpRequest::responseArrayBuffer()
 {
     ASSERT(m_responseTypeCode == ResponseTypeArrayBuffer);
 
-    if (m_error || m_state != DONE)
+    if (m_error || m_state != kDone)
         return nullptr;
 
     if (!m_responseArrayBuffer) {
         if (m_binaryResponseBuilder && m_binaryResponseBuilder->size()) {
             DOMArrayBuffer* buffer = DOMArrayBuffer::createUninitialized(m_binaryResponseBuilder->size(), 1);
             if (!m_binaryResponseBuilder->getAsBytes(buffer->data(), static_cast<size_t>(buffer->byteLength()))) {
                 // m_binaryResponseBuilder failed to allocate an ArrayBuffer.
                 // We need to crash the renderer since there's no way defined in
                 // the spec to tell this to the user.
                 CRASH();
             }
             m_responseArrayBuffer = buffer;
             m_binaryResponseBuilder.clear();
         } else {
             m_responseArrayBuffer = DOMArrayBuffer::create(nullptr, 0);
         }
     }
 
     return m_responseArrayBuffer.get();
 }
 
 Stream* XMLHttpRequest::responseLegacyStream()
 {
     ASSERT(m_responseTypeCode == ResponseTypeLegacyStream);
 
-    if (m_error || (m_state != LOADING && m_state != DONE))
+    if (m_error || (m_state != kLoading && m_state != kDone))
         return nullptr;
 
     return m_responseLegacyStream;
 }
 
 void XMLHttpRequest::setTimeout(unsigned timeout, ExceptionState& exceptionState)
 {
     // FIXME: Need to trigger or update the timeout Timer here, if needed. http://webkit.org/b/98156
     // XHR2 spec, 4.7.3. "This implies that the timeout attribute can be set while fetching is in progress. If that occurs it will still be measured relative to the start of fetching."
     if (getExecutionContext()->isDocument() && !m_async) {
         exceptionState.throwDOMException(InvalidAccessError, "Timeouts cannot be set for synchronous requests made from a document.");
         return;
     }
 
     m_timeoutMilliseconds = timeout;
 
     // From http://www.w3.org/TR/XMLHttpRequest/#the-timeout-attribute:
     // Note: This implies that the timeout attribute can be set while fetching is in progress. If
     // that occurs it will still be measured relative to the start of fetching.
     //
     // The timeout may be overridden after send.
     if (m_loader)
         m_loader->overrideTimeout(timeout);
 }
 
 void XMLHttpRequest::setResponseType(const String& responseType, ExceptionState& exceptionState)
 {
-    if (m_state >= LOADING) {
+    if (m_state >= kLoading) {
         exceptionState.throwDOMException(InvalidStateError, "The response type cannot be set if the object's state is LOADING or DONE.");
         return;
     }
 
     // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
     // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
     if (!m_async && getExecutionContext()->isDocument()) {
         exceptionState.throwDOMException(InvalidAccessError, "The response type cannot be changed for synchronous requests made from a document.");
         return;
     }
@@ skipping 53 matching lines @@
 {
     if (!m_upload)
         m_upload = XMLHttpRequestUpload::create(this);
     return m_upload.get();
 }
 
 void XMLHttpRequest::trackProgress(long long length)
 {
     m_receivedLength += length;
 
-    changeState(LOADING);
+    changeState(kLoading);
     if (m_async) {
         // readyStateChange event is fired as well.
         dispatchProgressEventFromSnapshot(EventTypeNames::progress);
     }
 }
 
 void XMLHttpRequest::changeState(State newState)
 {
     if (m_state != newState) {
         m_state = newState;
         dispatchReadyStateChangeEvent();
     }
 }
 
 void XMLHttpRequest::dispatchReadyStateChangeEvent()
 {
     if (!getExecutionContext())
         return;
 
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
-    if (m_async || (m_state <= OPENED || m_state == DONE)) {
+    if (m_async || (m_state <= kOpened || m_state == kDone)) {
         TRACE_EVENT1("devtools.timeline", "XHRReadyStateChange", "data", InspectorXhrReadyStateChangeEvent::data(getExecutionContext(), this));
         XMLHttpRequestProgressEventThrottle::DeferredEventAction action = XMLHttpRequestProgressEventThrottle::Ignore;
-        if (m_state == DONE) {
+        if (m_state == kDone) {
             if (m_error)
                 action = XMLHttpRequestProgressEventThrottle::Clear;
             else
                 action = XMLHttpRequestProgressEventThrottle::Flush;
         }
         m_progressEventThrottle->dispatchReadyStateChangeEvent(Event::create(EventTypeNames::readystatechange), action);
         TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data", InspectorUpdateCountersEvent::data());
     }
 
-    if (m_state == DONE && !m_error) {
+    if (m_state == kDone && !m_error) {
         TRACE_EVENT1("devtools.timeline", "XHRLoad", "data", InspectorXhrLoadEvent::data(getExecutionContext(), this));
         dispatchProgressEventFromSnapshot(EventTypeNames::load);
         dispatchProgressEventFromSnapshot(EventTypeNames::loadend);
         TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data", InspectorUpdateCountersEvent::data());
     }
 }
 
 void XMLHttpRequest::setWithCredentials(bool value, ExceptionState& exceptionState)
 {
-    if (m_state > OPENED || m_loader) {
+    if (m_state > kOpened || m_loader) {
         exceptionState.throwDOMException(InvalidStateError,  "The value may only be set if the object's state is UNSENT or OPENED.");
         return;
     }
 
     m_includeCredentials = value;
 }
 
 void XMLHttpRequest::open(const AtomicString& method, const String& urlString, ExceptionState& exceptionState)
 {
     open(method, getExecutionContext()->completeURL(urlString), true, exceptionState);
@@ skipping 11 matching lines @@
 }
 
 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);
 
     if (!internalAbort())
         return;
 
     State previousState = m_state;
-    m_state = UNSENT;
+    m_state = kUnsent;
     m_error = false;
     m_uploadComplete = false;
 
     if (!isValidHTTPToken(method)) {
         exceptionState.throwDOMException(SyntaxError, "'" + method + "' is not a valid HTTP method.");
         return;
     }
 
     if (FetchUtils::isForbiddenMethod(method)) {
         exceptionState.throwSecurityError("'" + method + "' HTTP method is unsupported.");
@@ skipping 36 matching lines @@
     m_method = FetchUtils::normalizeMethod(method);
 
     m_url = url;
 
     m_async = async;
 
     ASSERT(!m_loader);
 
     // Check previous state to avoid dispatching readyState event
     // when calling open several times in a row.
-    if (previousState != OPENED)
-        changeState(OPENED);
+    if (previousState != kOpened)
+        changeState(kOpened);
     else
-        m_state = OPENED;
+        m_state = kOpened;
 }
 
 bool XMLHttpRequest::initSend(ExceptionState& exceptionState)
 {
     if (!getExecutionContext())
         return false;
 
-    if (m_state != OPENED || m_loader) {
+    if (m_state != kOpened || m_loader) {
         exceptionState.throwDOMException(InvalidStateError, "The object's state must be OPENED.");
         return false;
     }
 
     if (!m_async && exceptionState.isolate() && v8::MicrotasksScope::IsRunningMicrotasks(exceptionState.isolate())) {
         Deprecation::countDeprecation(getExecutionContext(), UseCounter::During_Microtask_SyncXHR);
         if (RuntimeEnabledFeatures::disableBlockingMethodsDuringMicrotasksEnabled()) {
             exceptionState.throwDOMException(InvalidAccessError, "Cannot send() synchronous requests during microtask execution.");
             return false;
         }
@@ skipping 326 matching lines @@
     // The script never gets any chance to call abort() on a sync XHR between
     // send() call and transition to the DONE state. It's because a sync XHR
     // doesn't dispatch any event between them. So, if |m_async| is false, we
     // can skip the "request error steps" (defined in the XHR spec) without any
     // state check.
     //
     // FIXME: It's possible open() is invoked in internalAbort() and |m_async|
     // becomes true by that. We should implement more reliable treatment for
     // nested method invocations at some point.
     if (m_async) {
-        if ((m_state == OPENED && sendFlag) || m_state == HEADERS_RECEIVED || m_state == LOADING) {
+        if ((m_state == kOpened && sendFlag) || m_state == kHeadersReceived || m_state == kLoading) {
             ASSERT(!m_loader);
             handleRequestError(0, EventTypeNames::abort, receivedLength, expectedLength);
         }
     }
-    m_state = UNSENT;
+    m_state = kUnsent;
 }
 
 void XMLHttpRequest::clearVariablesForLoading()
 {
     if (m_blobLoader) {
         m_blobLoader->cancel();
         m_blobLoader = nullptr;
     }
 
     m_decoder.reset();
 
     if (m_responseDocumentParser) {
         m_responseDocumentParser->removeClient(this);
         m_responseDocumentParser->detach();
         m_responseDocumentParser = nullptr;
     }
 
     m_finalResponseCharset = String();
 }
 
 bool XMLHttpRequest::internalAbort()
 {
     m_error = true;
 
     if (m_responseDocumentParser && !m_responseDocumentParser->isStopped())
         m_responseDocumentParser->stopParsing();
 
     clearVariablesForLoading();
 
-    if (m_responseLegacyStream && m_state != DONE)
+    if (m_responseLegacyStream && m_state != kDone)
         m_responseLegacyStream->abort();
 
     clearResponse();
     clearRequest();
 
     if (!m_loader)
         return true;
 
     // Cancelling the ThreadableLoader m_loader may result in calling
     // window.onload synchronously. If such an onload handler contains open()
@@ skipping 93 matching lines @@
 }
 
 void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type, long long receivedLength, long long expectedLength)
 {
     WTF_LOG(Network, "XMLHttpRequest %p handleRequestError()", this);
 
     InspectorInstrumentation::didFailXHRLoading(getExecutionContext(), this, this, m_method, m_url);
 
     if (!m_async) {
         ASSERT(exceptionCode);
-        m_state = DONE;
+        m_state = kDone;
         m_exceptionCode = exceptionCode;
         return;
     }
 
     // With m_error set, the state change steps are minimal: any pending
     // progress event is flushed + a readystatechange is dispatched.
     // No new progress events dispatched; as required, that happens at
     // the end here.
     ASSERT(m_error);
-    changeState(DONE);
+    changeState(kDone);
 
     if (!m_uploadComplete) {
         m_uploadComplete = true;
         if (m_upload && m_uploadEventsAllowed)
             m_upload->handleRequestError(type);
     }
 
     // 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& mimeType, ExceptionState& exceptionState)
 {
-    if (m_state == LOADING || m_state == DONE) {
+    if (m_state == kLoading || m_state == kDone) {
         exceptionState.throwDOMException(InvalidStateError, "MimeType cannot be overridden when the state is LOADING or DONE.");
         return;
     }
 
     m_mimeTypeOverride = mimeType;
 }
 
 void XMLHttpRequest::setRequestHeader(const AtomicString& name, const AtomicString& value, ExceptionState& exceptionState)
 {
-    if (m_state != OPENED || m_loader) {
+    if (m_state != kOpened || m_loader) {
         exceptionState.throwDOMException(InvalidStateError, "The object's state must be OPENED.");
         return;
     }
 
     if (!isValidHTTPToken(name)) {
         exceptionState.throwDOMException(SyntaxError, "'" + name + "' is not a valid HTTP header field name.");
         return;
     }
 
     if (!isValidHTTPHeaderValue(value)) {
@@ skipping 40 matching lines @@
     headerValueCategoryHistogram.count(headerValueCategory);
 }
 
 const AtomicString& XMLHttpRequest::getRequestHeader(const AtomicString& name) const
 {
     return m_requestHeaders.get(name);
 }
 
 String XMLHttpRequest::getAllResponseHeaders() const
 {
-    if (m_state < HEADERS_RECEIVED || m_error)
+    if (m_state < kHeadersReceived || m_error)
         return "";
 
     StringBuilder stringBuilder;
 
     HTTPHeaderSet accessControlExposeHeaderSet;
     extractCorsExposedHeaderNamesList(m_response, accessControlExposeHeaderSet);
 
     HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
     for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it!= end; ++it) {
         // Hide any headers whose name is a forbidden response-header name.
@@ skipping 13 matching lines @@
         stringBuilder.append(it->value);
         stringBuilder.append('\r');
         stringBuilder.append('\n');
     }
 
     return stringBuilder.toString();
 }
 
 const AtomicString& XMLHttpRequest::getResponseHeader(const AtomicString& name) const
 {
-    if (m_state < HEADERS_RECEIVED || m_error)
+    if (m_state < kHeadersReceived || m_error)
         return nullAtom;
 
     // See comment in getAllResponseHeaders above.
     if (FetchUtils::isForbiddenResponseHeaderName(name) && !getSecurityOrigin()->canLoadLocalResources()) {
         logConsoleError(getExecutionContext(), "Refused to get unsafe header \"" + name + "\"");
         return nullAtom;
     }
 
     HTTPHeaderSet accessControlExposeHeaderSet;
     extractCorsExposedHeaderNamesList(m_response, accessControlExposeHeaderSet);
@@ skipping 33 matching lines @@
     return DOMImplementation::isXMLMIMEType(finalResponseMIMETypeWithFallback());
 }
 
 bool XMLHttpRequest::responseIsHTML() const
 {
     return equalIgnoringCase(finalResponseMIMEType(), "text/html");
 }
 
 int XMLHttpRequest::status() const
 {
-    if (m_state == UNSENT || m_state == OPENED || m_error)
+    if (m_state == kUnsent || m_state == kOpened || m_error)
         return 0;
 
     if (m_response.httpStatusCode())
         return m_response.httpStatusCode();
 
     return 0;
 }
 
 String XMLHttpRequest::statusText() const
 {
-    if (m_state == UNSENT || m_state == OPENED || m_error)
+    if (m_state == kUnsent || m_state == kOpened || m_error)
         return String();
 
     if (!m_response.httpStatusText().isNull())
         return m_response.httpStatusText();
 
     return String();
 }
 
 void XMLHttpRequest::didFail(const ResourceError& error)
 {
@@ skipping 34 matching lines @@
 }
 
 void XMLHttpRequest::didFinishLoading(unsigned long identifier, double)
 {
     WTF_LOG(Network, "XMLHttpRequest %p didFinishLoading(%lu)", this, identifier);
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     if (m_error)
         return;
 
-    if (m_state < HEADERS_RECEIVED)
-        changeState(HEADERS_RECEIVED);
+    if (m_state < kHeadersReceived)
+        changeState(kHeadersReceived);
 
     if (m_downloadingToFile && m_responseTypeCode != ResponseTypeBlob && m_lengthDownloadedToFile) {
-        ASSERT(m_state == LOADING);
+        DCHECK_EQ(kLoading, m_state);
         // In this case, we have sent the request with DownloadToFile true,
         // but the user changed the response type after that. Hence we need to
         // read the response data and provide it to this object.
         m_blobLoader = BlobLoader::create(this, createBlobDataHandleFromResponse());
     } else {
         didFinishLoadingInternal();
     }
 }
 
 void XMLHttpRequest::didFinishLoadingInternal()
@@ skipping 82 matching lines @@
     endLoading();
 }
 
 void XMLHttpRequest::endLoading()
 {
     InspectorInstrumentation::didFinishXHRLoading(getExecutionContext(), this, this, m_method, m_url);
 
     if (m_loader)
         m_loader = nullptr;
 
-    changeState(DONE);
+    changeState(kDone);
 
     if (!getExecutionContext()->isDocument() || !document() || !document()->frame() || !document()->frame()->page())
         return;
 
     if (status() >= 200 && status() < 300) {
         document()->frame()->page()->chromeClient().ajaxSucceeded(document()->frame());
     }
 }
 
 void XMLHttpRequest::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
@@ skipping 73 matching lines @@
 
     return TextResourceDecoder::create("text/plain", "UTF-8");
 }
 
 void XMLHttpRequest::didReceiveData(const char* data, unsigned len)
 {
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
     if (m_error)
         return;
 
-    if (m_state < HEADERS_RECEIVED)
-        changeState(HEADERS_RECEIVED);
+    if (m_state < kHeadersReceived)
+        changeState(kHeadersReceived);
 
     // We need to check for |m_error| again, because |changeState| may trigger
     // readystatechange, and user javascript can cause |abort()|.
     if (m_error)
         return;
 
     if (!len)
         return;
 
     if (m_responseTypeCode == ResponseTypeDocument && responseIsHTML()) {
@@ skipping 27 matching lines @@
 }
 
 void XMLHttpRequest::didDownloadData(int dataLength)
 {
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
     if (m_error)
         return;
 
     ASSERT(m_downloadingToFile);
 
-    if (m_state < HEADERS_RECEIVED)
-        changeState(HEADERS_RECEIVED);
+    if (m_state < kHeadersReceived)
+        changeState(kHeadersReceived);
 
     if (!dataLength)
         return;
 
     // readystatechange event handler may do something to put this XHR in error
     // state. We need to check m_error again here.
     if (m_error)
         return;
 
     m_lengthDownloadedToFile += dataLength;
@@ skipping 78 matching lines @@
 
 DEFINE_TRACE_WRAPPERS(XMLHttpRequest)
 {
     visitor->traceWrappers(m_responseBlob);
     visitor->traceWrappers(m_responseLegacyStream);
     visitor->traceWrappers(m_responseDocument);
     visitor->traceWrappers(m_responseArrayBuffer);
 }
 
 } // namespace blink