Replace WTF_LOG() with NETWORK_DVLOG() or RESOURCE_LOADING_DVLOG().

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 47 matching lines @@
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/streams/Stream.h"
 #include "core/xmlhttprequest/XMLHttpRequestUpload.h"
 #include "platform/FileMetadata.h"
 #include "platform/HTTPNames.h"
 #include "platform/Histogram.h"
-#include "platform/Logging.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/blob/BlobData.h"
 #include "platform/network/HTTPParsers.h"
+#include "platform/network/NetworkLog.h"
 #include "platform/network/ParsedContentType.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/Assertions.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CString.h"
 #include <memory>
 
 namespace blink {
@@ skipping 462 matching lines @@
     if (!username.isNull())
         url.setUser(username);
     if (!password.isNull())
         url.setPass(password);
 
     open(method, url, async, 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);
+    NETWORK_DVLOG(1) << this << " open(" << method << ", " << url.elidedString() << ", " << async << ")";

[tyoshino (SeeGerritForStatus), 2016/08/12 07:32:19]

ditto

 
     if (!internalAbort())
         return;
 
     State previousState = m_state;
     m_state = kUnsent;
     m_error = false;
     m_uploadComplete = false;
 
     if (!isValidHTTPToken(method)) {
@@ skipping 112 matching lines @@
     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)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p send() Document %p", this, document);
+    NETWORK_DVLOG(1) << this << " send() Document " << static_cast<void*>(document);
 
     ASSERT(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()|.
         if (getRequestHeader(HTTPNames::Content_Type).isEmpty())
             setRequestHeaderInternal(HTTPNames::Content_Type, "application/xml;charset=UTF-8");
 
         String body = createMarkup(document);
 
         httpBody = EncodedFormData::create(UTF8Encoding().encode(body, WTF::EntitiesForUnencodables));
     }
 
     createRequest(httpBody.release(), exceptionState);
 }
 
 void XMLHttpRequest::send(const String& body, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p send() String '%s'", this, body.utf8().data());
+    NETWORK_DVLOG(1) << this << " send() String " << body;
 
     if (!initSend(exceptionState))
         return;
 
     RefPtr<EncodedFormData> httpBody;
 
     if (!body.isNull() && areMethodAndURLValidForSend()) {
         String contentType = getRequestHeader(HTTPNames::Content_Type);
         if (contentType.isEmpty()) {
             setRequestHeaderInternal(HTTPNames::Content_Type, "text/plain;charset=UTF-8");
         } else {
             replaceCharsetInMediaType(contentType, "UTF-8");
             m_requestHeaders.set(HTTPNames::Content_Type, AtomicString(contentType));
         }
 
         httpBody = EncodedFormData::create(UTF8Encoding().encode(body, WTF::EntitiesForUnencodables));
     }
 
     createRequest(httpBody.release(), exceptionState);
 }
 
 void XMLHttpRequest::send(Blob* body, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p send() Blob '%s'", this, body->uuid().utf8().data());
+    NETWORK_DVLOG(1) << this << " send() Blob " << body->uuid();
 
     if (!initSend(exceptionState))
         return;
 
     RefPtr<EncodedFormData> httpBody;
 
     if (areMethodAndURLValidForSend()) {
         if (getRequestHeader(HTTPNames::Content_Type).isEmpty()) {
             const String& blobType = body->type();
             if (!blobType.isEmpty() && isValidContentType(blobType)) {
@@ skipping 14 matching lines @@
         } else {
             httpBody->appendBlob(body->uuid(), body->blobDataHandle());
         }
     }
 
     createRequest(httpBody.release(), exceptionState);
 }
 
 void XMLHttpRequest::send(FormData* body, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p send() FormData %p", this, body);
+    NETWORK_DVLOG(1) << this << " send() FormData " << body;
 
     if (!initSend(exceptionState))
         return;
 
     RefPtr<EncodedFormData> httpBody;
 
     if (areMethodAndURLValidForSend()) {
         httpBody = body->encodeMultiPartFormData();
 
         if (getRequestHeader(HTTPNames::Content_Type).isEmpty()) {
             AtomicString contentType = AtomicString("multipart/form-data; boundary=") + httpBody->boundary().data();
             setRequestHeaderInternal(HTTPNames::Content_Type, contentType);
         }
     }
 
     createRequest(httpBody.release(), exceptionState);
 }
 
 void XMLHttpRequest::send(DOMArrayBuffer* body, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p send() ArrayBuffer %p", this, body);
+    NETWORK_DVLOG(1) << this << " send() ArrayBuffer " << body;
 
     sendBytesData(body->data(), body->byteLength(), exceptionState);
 }
 
 void XMLHttpRequest::send(DOMArrayBufferView* body, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p send() ArrayBufferView %p", this, body);
+    NETWORK_DVLOG(1) << this << " send() ArrayBufferView " << body;
 
     sendBytesData(body->baseAddress(), body->byteLength(), exceptionState);
 }
 
 void XMLHttpRequest::sendBytesData(const void* data, size_t length, ExceptionState& exceptionState)
 {
     if (!initSend(exceptionState))
         return;
 
     RefPtr<EncodedFormData> httpBody;
@@ skipping 122 matching lines @@
 
     // Use count for XHR synchronous requests.
     UseCounter::count(&executionContext, UseCounter::XMLHttpRequestSynchronous);
     ThreadableLoader::loadResourceSynchronously(executionContext, request, *this, options, resourceLoaderOptions);
 
     throwForLoadFailureIfNeeded(exceptionState, String());
 }
 
 void XMLHttpRequest::abort()
 {
-    WTF_LOG(Network, "XMLHttpRequest %p abort()", this);
+    NETWORK_DVLOG(1) << this << " abort()";
 
     // internalAbort() clears |m_loader|. Compute |sendFlag| now.
     //
     // |sendFlag| corresponds to "the send() flag" defined in the XHR spec.
     //
     // |sendFlag| is only set when we have an active, asynchronous loader.
     // Don't use it as "the send() flag" when the XHR is in sync mode.
     bool sendFlag = m_loader.get();
 
     // internalAbort() clears the response. Save the data needed for
@@ skipping 122 matching lines @@
         InspectorInstrumentation::asyncTaskCanceled(context, this);
 }
 
 void XMLHttpRequest::dispatchProgressEventFromSnapshot(const AtomicString& type)
 {
     dispatchProgressEvent(type, m_receivedLength, m_response.expectedContentLength());
 }
 
 void XMLHttpRequest::handleNetworkError()
 {
-    WTF_LOG(Network, "XMLHttpRequest %p handleNetworkError()", this);
+    NETWORK_DVLOG(1) << this << " handleNetworkError()";
 
     // Response is cleared next, save needed progress event data.
     long long expectedLength = m_response.expectedContentLength();
     long long receivedLength = m_receivedLength;
 
     if (!internalAbort())
         return;
 
     handleRequestError(NetworkError, EventTypeNames::error, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::handleDidCancel()
 {
-    WTF_LOG(Network, "XMLHttpRequest %p handleDidCancel()", this);
+    NETWORK_DVLOG(1) << this << " handleDidCancel()";
 
     // Response is cleared next, save needed progress event data.
     long long expectedLength = m_response.expectedContentLength();
     long long receivedLength = m_receivedLength;
 
     if (!internalAbort())
         return;
 
     handleRequestError(AbortError, EventTypeNames::abort, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type, long long receivedLength, long long expectedLength)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p handleRequestError()", this);
+    NETWORK_DVLOG(1) << this << " handleRequestError()";
 
     InspectorInstrumentation::didFailXHRLoading(getExecutionContext(), this, this, m_method, m_url);
 
     if (!m_async) {
         ASSERT(exceptionCode);
         m_state = kDone;
         m_exceptionCode = exceptionCode;
         return;
     }
 
@@ skipping 194 matching lines @@
         return String();
 
     if (!m_response.httpStatusText().isNull())
         return m_response.httpStatusText();
 
     return String();
 }
 
 void XMLHttpRequest::didFail(const ResourceError& error)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p didFail()", this);
+    NETWORK_DVLOG(1) << this << " didFail()";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     // If we are already in an error state, for instance we called abort(), bail out early.
     if (m_error)
         return;
 
     if (error.isCancellation()) {
         handleDidCancel();
         // Now the XMLHttpRequest instance may be dead.
         return;
     }
 
     if (error.isTimeout()) {
         handleDidTimeout();
         // Now the XMLHttpRequest instance may be dead.
         return;
     }
 
     // Network failures are already reported to Web Inspector by ResourceLoader.
     if (error.domain() == errorDomainBlinkInternal)
         logConsoleError(getExecutionContext(), "XMLHttpRequest cannot load " + error.failingURL() + ". " + error.localizedDescription());
 
     handleNetworkError();
     // Now the XMLHttpRequest instance may be dead.
 }
 
 void XMLHttpRequest::didFailRedirectCheck()
 {
-    WTF_LOG(Network, "XMLHttpRequest %p didFailRedirectCheck()", this);
+    NETWORK_DVLOG(1) << this << " didFailRedirectCheck()";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     handleNetworkError();
     // Now the XMLHttpRequest instance may be dead.
 }
 
 void XMLHttpRequest::didFinishLoading(unsigned long identifier, double)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p didFinishLoading(%lu)", this, identifier);
+    NETWORK_DVLOG(1) << this << " didFinishLoading(" << identifier << ")";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     if (m_error)
         return;
 
     if (m_state < kHeadersReceived)
         changeState(kHeadersReceived);
 
     if (m_downloadingToFile && m_responseTypeCode != ResponseTypeBlob && m_lengthDownloadedToFile) {
         DCHECK_EQ(kLoading, m_state);
@@ skipping 28 matching lines @@
 
     if (m_responseLegacyStream)
         m_responseLegacyStream->finalize();
 
     clearVariablesForLoading();
     endLoading();
 }
 
 void XMLHttpRequest::didFinishLoadingFromBlob()
 {
-    WTF_LOG(Network, "XMLHttpRequest %p didFinishLoadingFromBlob", this);
+    NETWORK_DVLOG(1) << this << " didFinishLoadingFromBlob";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     didFinishLoadingInternal();
 }
 
 void XMLHttpRequest::didFailLoadingFromBlob()
 {
-    WTF_LOG(Network, "XMLHttpRequest %p didFailLoadingFromBlob()", this);
+    NETWORK_DVLOG(1) << this << " didFailLoadingFromBlob()";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     if (m_error)
         return;
     handleNetworkError();
 }
 
 PassRefPtr<BlobDataHandle> XMLHttpRequest::createBlobDataHandleFromResponse()
 {
     ASSERT(m_downloadingToFile);
@@ skipping 49 matching lines @@
     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)
 {
-    WTF_LOG(Network, "XMLHttpRequest %p didSendData(%llu, %llu)", this, bytesSent, totalBytesToBeSent);
+    NETWORK_DVLOG(1) << this << " didSendData(" << bytesSent << ", " << totalBytesToBeSent << ")";
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
     if (!m_upload)
         return;
 
     if (m_uploadEventsAllowed)
         m_upload->dispatchProgressEvent(bytesSent, totalBytesToBeSent);
 
     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);
-    WTF_LOG(Network, "XMLHttpRequest %p didReceiveResponse(%lu)", this, identifier);
+    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();
@@ skipping 109 matching lines @@
     if (m_error)
         return;
 
     m_lengthDownloadedToFile += dataLength;
 
     trackProgress(dataLength);
 }
 
 void XMLHttpRequest::handleDidTimeout()
 {
-    WTF_LOG(Network, "XMLHttpRequest %p handleDidTimeout()", this);
+    NETWORK_DVLOG(1) << this << " handleDidTimeout()";
 
     // Response is cleared next, save needed progress event data.
     long long expectedLength = m_response.expectedContentLength();
     long long receivedLength = m_receivedLength;
 
     if (!internalAbort())
         return;
 
     handleRequestError(TimeoutError, EventTypeNames::timeout, receivedLength, expectedLength);
 }
@@ skipping 60 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(XMLHttpRequest)
 {
     visitor->traceWrappers(m_responseBlob);
     visitor->traceWrappers(m_responseLegacyStream);
     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