Replace ASSERT*() with DCHECK*() in core/xmlhttprequest/

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 76 matching lines @@
 // via hasPendingActivity method which returns true if
 // m_eventDispatchRecursionLevel is positive.
 class ScopedEventDispatchProtect final {
 public:
     explicit ScopedEventDispatchProtect(int* level) : m_level(level)
     {
         ++*m_level;
     }
     ~ScopedEventDispatchProtect()
     {
-        ASSERT(*m_level > 0);
+        DCHECK_GT(*m_level, 0);
         --*m_level;
     }
 
 private:
     int* const m_level;
 };
 
 void replaceCharsetInMediaType(String& mediaType, const String& charsetValue)
 {
     unsigned pos = 0, len = 0;
@@ skipping 56 matching lines @@
 public:
     static BlobLoader* create(XMLHttpRequest* xhr, PassRefPtr<BlobDataHandle> handle)
     {
         return new BlobLoader(xhr, std::move(handle));
     }
 
     // FileReaderLoaderClient functions.
     void didStartLoading() override {}
     void didReceiveDataForClient(const char* data, unsigned length) override
     {
-        ASSERT(length <= INT_MAX);
+        DCHECK_LE(length, static_cast<unsigned>(INT_MAX));
         m_xhr->didReceiveData(data, length);
     }
     void didFinishLoading() override
     {
         m_xhr->didFinishLoadingFromBlob();
     }
     void didFail(FileError::ErrorCode error) override
     {
         m_xhr->didFailLoadingFromBlob();
     }
@@ skipping 62 matching lines @@
     , m_responseTextOverflow(false)
 {
 }
 
 XMLHttpRequest::~XMLHttpRequest()
 {
 }
 
 Document* XMLHttpRequest::document() const
 {
-    ASSERT(getExecutionContext()->isDocument());
+    DCHECK(getExecutionContext()->isDocument());
     return toDocument(getExecutionContext());
 }
 
 SecurityOrigin* XMLHttpRequest::getSecurityOrigin() const
 {
     return m_isolatedWorldSecurityOrigin ? m_isolatedWorldSecurityOrigin.get() : getExecutionContext()->getSecurityOrigin();
 }
 
 XMLHttpRequest::State XMLHttpRequest::readyState() const
 {
     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 != kLoading && m_state != kDone))
         return ScriptString();
     return m_responseText;
 }
 
 ScriptString XMLHttpRequest::responseJSONSource()
 {
-    ASSERT(m_responseTypeCode == ResponseTypeJSON);
+    DCHECK_EQ(m_responseTypeCode, ResponseTypeJSON);
 
     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.
@@ skipping 37 matching lines @@
             m_responseDocument = nullptr;
 
         m_parsedResponse = true;
     }
 
     return m_responseDocument.get();
 }
 
 Blob* XMLHttpRequest::responseBlob()
 {
-    ASSERT(m_responseTypeCode == ResponseTypeBlob);
+    DCHECK_EQ(m_responseTypeCode, ResponseTypeBlob);
 
     // We always return null before kDone.
     if (m_error || m_state != kDone)
         return nullptr;
 
     if (!m_responseBlob) {
         if (m_downloadingToFile) {
-            ASSERT(!m_binaryResponseBuilder);
+            DCHECK(!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.
             m_responseBlob = Blob::create(createBlobDataHandleFromResponse());
         } else {
             std::unique_ptr<BlobData> blobData = BlobData::create();
             size_t size = 0;
             if (m_binaryResponseBuilder && m_binaryResponseBuilder->size()) {
                 size = m_binaryResponseBuilder->size();
                 blobData->appendBytes(m_binaryResponseBuilder->data(), size);
                 blobData->setContentType(finalResponseMIMETypeWithFallback().lower());
                 m_binaryResponseBuilder.clear();
             }
             m_responseBlob = Blob::create(BlobDataHandle::create(std::move(blobData), size));
         }
     }
 
     return m_responseBlob;
 }
 
 DOMArrayBuffer* XMLHttpRequest::responseArrayBuffer()
 {
-    ASSERT(m_responseTypeCode == ResponseTypeArrayBuffer);
+    DCHECK_EQ(m_responseTypeCode, ResponseTypeArrayBuffer);
 
     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);
+    DCHECK_EQ(m_responseTypeCode, ResponseTypeLegacyStream);
 
     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
@@ skipping 39 matching lines @@
     } else if (responseType == "blob") {
         m_responseTypeCode = ResponseTypeBlob;
     } else if (responseType == "arraybuffer") {
         m_responseTypeCode = ResponseTypeArrayBuffer;
     } else if (responseType == "legacystream") {
         if (RuntimeEnabledFeatures::experimentalStreamEnabled())
             m_responseTypeCode = ResponseTypeLegacyStream;
         else
             return;
     } else {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
 }
 
 String XMLHttpRequest::responseType()
 {
     switch (m_responseTypeCode) {
     case ResponseTypeDefault:
         return "";
     case ResponseTypeText:
         return "text";
@@ skipping 151 matching lines @@
         if (!document()->processingBeforeUnload())
             Deprecation::countDeprecation(getExecutionContext(), UseCounter::XMLHttpRequestSynchronousInNonWorkerOutsideBeforeUnload);
     }
 
     m_method = FetchUtils::normalizeMethod(method);
 
     m_url = url;
 
     m_async = async;
 
-    ASSERT(!m_loader);
+    DCHECK(!m_loader);
 
     // Check previous state to avoid dispatching readyState event
     // when calling open several times in a row.
     if (previousState != kOpened)
         changeState(kOpened);
     else
         m_state = kOpened;
 }
 
 bool XMLHttpRequest::initSend(ExceptionState& exceptionState)
@@ skipping 44 matching lines @@
     if (body.isDocument()) {
         send(body.getAsDocument(), exceptionState);
         return;
     }
 
     if (body.isFormData()) {
         send(body.getAsFormData(), exceptionState);
         return;
     }
 
-    ASSERT(body.isString());
+    DCHECK(body.isString());
     send(body.getAsString(), exceptionState);
 }
 
 bool XMLHttpRequest::areMethodAndURLValidForSend()
 {
     return m_method != HTTPNames::GET && m_method != HTTPNames::HEAD && m_url.protocolIsInHTTPFamily();
 }
 
 void XMLHttpRequest::send(Document* document, ExceptionState& exceptionState)
 {
     NETWORK_DVLOG(1) << this << " send() Document " << static_cast<void*>(document);
 
-    ASSERT(document);
+    DCHECK(document);
 
     if (!initSend(exceptionState))
         return;
 
     RefPtr<EncodedFormData> httpBody;
 
     if (areMethodAndURLValidForSend()) {
         // FIXME: Per https://xhr.spec.whatwg.org/#dom-xmlhttprequest-send the
         // Content-Type header and whether to serialize as HTML or XML should
         // depend on |document->isHTMLDocument()|.
@@ skipping 51 matching lines @@
 
         // FIXME: add support for uploading bundles.
         httpBody = EncodedFormData::create();
         if (body->hasBackingFile()) {
             File* file = toFile(body);
             if (!file->path().isEmpty())
                 httpBody->appendFile(file->path());
             else if (!file->fileSystemURL().isEmpty())
                 httpBody->appendFileSystemURL(file->fileSystemURL());
             else
-                ASSERT_NOT_REACHED();
+                NOTREACHED();
         } else {
             httpBody->appendBlob(body->uuid(), body->blobDataHandle());
         }
     }
 
     createRequest(httpBody.release(), exceptionState);
 }
 
 void XMLHttpRequest::send(FormData* body, ExceptionState& exceptionState)
 {
@@ skipping 74 matching lines @@
     // Only GET request is supported for blob URL.
     if (m_url.protocolIs("blob") && m_method != HTTPNames::GET) {
         handleNetworkError();
 
         if (!m_async) {
             throwForLoadFailureIfNeeded(exceptionState, "'GET' is the only method allowed for 'blob:' URLs.");
         }
         return;
     }
 
-    ASSERT(getExecutionContext());
+    DCHECK(getExecutionContext());
     ExecutionContext& executionContext = *this->getExecutionContext();
 
     // The presence of upload event listeners forces us to use preflighting because POSTing to an URL that does not
     // permit cross origin requests should look exactly like POSTing to an URL that does not respond at all.
     // Also, only async requests support upload progress events.
     bool uploadEvents = false;
     if (m_async) {
         InspectorInstrumentation::asyncTaskScheduled(&executionContext, "XMLHttpRequest.send", this, true);
         dispatchProgressEvent(EventTypeNames::loadstart, 0, 0);
         if (httpBody && m_upload) {
@@ skipping 14 matching lines @@
     ResourceRequest request(m_url);
     request.setHTTPMethod(m_method);
     request.setRequestContext(WebURLRequest::RequestContextXMLHttpRequest);
     request.setFetchCredentialsMode(m_includeCredentials ? WebURLRequest::FetchCredentialsModeInclude : WebURLRequest::FetchCredentialsModeSameOrigin);
     request.setSkipServiceWorker(m_isolatedWorldSecurityOrigin.get() ? WebURLRequest::SkipServiceWorker::All : WebURLRequest::SkipServiceWorker::None);
     request.setExternalRequestStateFromRequestorAddressSpace(executionContext.securityContext().addressSpace());
 
     InspectorInstrumentation::willLoadXHR(&executionContext, this, this, m_method, m_url, m_async, httpBody ? httpBody->deepCopy() : nullptr, m_requestHeaders, m_includeCredentials);
 
     if (httpBody) {
-        ASSERT(m_method != HTTPNames::GET);
-        ASSERT(m_method != HTTPNames::HEAD);
+        DCHECK_NE(m_method, HTTPNames::GET);
+        DCHECK_NE(m_method, HTTPNames::HEAD);
         request.setHTTPBody(std::move(httpBody));
     }
 
     if (m_requestHeaders.size() > 0)
         request.addHTTPHeaderFields(m_requestHeaders);
 
     ThreadableLoaderOptions options;
     options.preflightPolicy = uploadEvents ? ForcePreflight : ConsiderPreflight;
     options.crossOriginRequestPolicy = UseAccessControl;
     options.initiator = FetchInitiatorTypeNames::xmlhttprequest;
@@ skipping 14 matching lines @@
     }
 
     m_exceptionCode = 0;
     m_error = false;
 
     if (m_async) {
         UseCounter::count(&executionContext, UseCounter::XMLHttpRequestAsynchronous);
         if (m_upload)
             request.setReportUploadProgress(true);
 
-        ASSERT(!m_loader);
+        DCHECK(!m_loader);
         m_loader = ThreadableLoader::create(executionContext, this, options, resourceLoaderOptions);
         m_loader->start(request);
 
         return;
     }
 
     // Use count for XHR synchronous requests.
     UseCounter::count(&executionContext, UseCounter::XMLHttpRequestSynchronous);
     ThreadableLoader::loadResourceSynchronously(executionContext, request, *this, options, resourceLoaderOptions);
 
@@ skipping 24 matching lines @@
     // 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 == kOpened && sendFlag) || m_state == kHeadersReceived || m_state == kLoading) {
-            ASSERT(!m_loader);
+            DCHECK(!m_loader);
             handleRequestError(0, EventTypeNames::abort, receivedLength, expectedLength);
         }
     }
     m_state = kUnsent;
 }
 
 void XMLHttpRequest::clearVariablesForLoading()
 {
     if (m_blobLoader) {
         m_blobLoader->cancel();
@@ skipping 126 matching lines @@
     handleRequestError(AbortError, EventTypeNames::abort, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type, long long receivedLength, long long expectedLength)
 {
     NETWORK_DVLOG(1) << this << " handleRequestError()";
 
     InspectorInstrumentation::didFailXHRLoading(getExecutionContext(), this, this, m_method, m_url);
 
     if (!m_async) {
-        ASSERT(exceptionCode);
+        DCHECK(exceptionCode);
         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);
+    DCHECK(m_error);
     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()|.
@@ skipping 241 matching lines @@
 }
 
 void XMLHttpRequest::didFinishLoadingInternal()
 {
     if (m_responseDocumentParser) {
         // |DocumentParser::finish()| tells the parser that we have reached end of the data.
         // When using |HTMLDocumentParser|, which works asynchronously, we do not have the
         // complete document just after the |DocumentParser::finish()| call.
         // Wait for the parser to call us back in |notifyParserStopped| to progress state.
         m_responseDocumentParser->finish();
-        ASSERT(m_responseDocument);
+        DCHECK(m_responseDocument);
         return;
     }
 
     if (m_decoder) {
         auto text = m_decoder->flush();
         if (!text.isEmpty() && !m_responseTextOverflow) {
             m_responseText = m_responseText.concatenateWith(text);
             m_responseTextOverflow = m_responseText.isEmpty();
         }
     }
@@ skipping 18 matching lines @@
     NETWORK_DVLOG(1) << this << " didFailLoadingFromBlob()";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     if (m_error)
         return;
     handleNetworkError();
 }
 
 PassRefPtr<BlobDataHandle> XMLHttpRequest::createBlobDataHandleFromResponse()
 {
-    ASSERT(m_downloadingToFile);
+    DCHECK(m_downloadingToFile);
     std::unique_ptr<BlobData> blobData = BlobData::create();
     String filePath = m_response.downloadedFilePath();
     // If we errored out or got no data, we return an empty handle.
     if (!filePath.isEmpty() && m_lengthDownloadedToFile) {
         blobData->appendFile(filePath, 0, m_lengthDownloadedToFile, invalidFileTime());
         // FIXME: finalResponseMIMETypeWithFallback() defaults to
         // text/xml which may be incorrect. Replace it with
         // finalResponseMIMEType() after compatibility investigation.
         blobData->setContentType(finalResponseMIMETypeWithFallback().lower());
     }
     return BlobDataHandle::create(std::move(blobData), m_lengthDownloadedToFile);
 }
 
 void XMLHttpRequest::notifyParserStopped()
 {
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     // This should only be called when response document is parsed asynchronously.
-    ASSERT(m_responseDocumentParser);
-    ASSERT(!m_responseDocumentParser->isParsing());
-    ASSERT(!m_responseLegacyStream);
+    DCHECK(m_responseDocumentParser);
+    DCHECK(!m_responseDocumentParser->isParsing());
+    DCHECK(!m_responseLegacyStream);
 
     // Do nothing if we are called from |internalAbort()|.
     if (m_error)
         return;
 
     clearVariablesForLoading();
 
     m_responseDocument->implicitClose();
 
     if (!m_responseDocument->wellFormed())
@@ skipping 41 matching lines @@
 
     if (bytesSent == totalBytesToBeSent && !m_uploadComplete) {
         m_uploadComplete = true;
         if (m_uploadEventsAllowed)
             m_upload->dispatchEventAndLoadEnd(EventTypeNames::load, true, bytesSent, totalBytesToBeSent);
     }
 }
 
 void XMLHttpRequest::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
-    ASSERT_UNUSED(handle, !handle);
+    ALLOW_UNUSED_LOCAL(handle);
+    DCHECK(!handle);
     NETWORK_DVLOG(1) << this << " didReceiveResponse(" << identifier << ")";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     m_response = response;
     if (!m_mimeTypeOverride.isEmpty()) {
         m_response.setHTTPHeaderField(HTTPNames::Content_Type, m_mimeTypeOverride);
         m_finalResponseCharset = extractCharsetFromMediaType(m_mimeTypeOverride);
     }
 
     if (m_finalResponseCharset.isEmpty())
         m_finalResponseCharset = response.textEncodingName();
 }
 
 void XMLHttpRequest::parseDocumentChunk(const char* data, unsigned len)
 {
     if (!m_responseDocumentParser) {
-        ASSERT(!m_responseDocument);
+        DCHECK(!m_responseDocument);
         initResponseDocument();
         if (!m_responseDocument)
             return;
 
         m_responseDocumentParser = m_responseDocument->implicitOpen(AllowAsynchronousParsing);
         m_responseDocumentParser->addClient(this);
     }
-    ASSERT(m_responseDocumentParser);
+    DCHECK(m_responseDocumentParser);
 
     if (m_responseDocumentParser->needsDecoder())
         m_responseDocumentParser->setDecoder(createDecoder());
 
     m_responseDocumentParser->appendBytes(data, len);
 }
 
 std::unique_ptr<TextResourceDecoder> XMLHttpRequest::createDecoder() const
 {
     if (m_responseTypeCode == ResponseTypeJSON)
@@ skipping 65 matching lines @@
     }
     trackProgress(len);
 }
 
 void XMLHttpRequest::didDownloadData(int dataLength)
 {
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
     if (m_error)
         return;
 
-    ASSERT(m_downloadingToFile);
+    DCHECK(m_downloadingToFile);
 
     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)
@@ skipping 43 matching lines @@
     // |m_loader| is non-null while request is active and ThreadableLoaderClient
     // callbacks may be called, and |m_responseDocumentParser| is non-null while
     // DocumentParserClient callbacks may be called.
     if (m_loader || m_responseDocumentParser)
         return true;
     return m_eventDispatchRecursionLevel > 0;
 }
 
 void XMLHttpRequest::contextDestroyed()
 {
-    ASSERT(!m_loader);
+    DCHECK(!m_loader);
     ActiveDOMObject::contextDestroyed();
 }
 
 const AtomicString& XMLHttpRequest::interfaceName() const
 {
     return EventTargetNames::XMLHttpRequest;
 }
 
 ExecutionContext* XMLHttpRequest::getExecutionContext() const
 {
@@ skipping 23 matching lines @@
     visitor->traceWrappers(m_responseDocument);
     visitor->traceWrappers(m_responseArrayBuffer);
 }
 
 std::ostream& operator<<(std::ostream& ostream, const XMLHttpRequest* xhr)
 {
     return ostream << "XMLHttpRequest " << static_cast<const void*>(xhr);
 }
 
 } // namespace blink