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

third_party/WebKit/Source/modules/websockets/DOMWebSocket.cpp

 /*
  * Copyright (C) 2011 Google Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 31 matching lines @@
 #include "core/dom/SecurityContext.h"
 #include "core/events/MessageEvent.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "modules/websockets/CloseEvent.h"
 #include "platform/Histogram.h"
-#include "platform/Logging.h"
 #include "platform/blob/BlobData.h"
+#include "platform/network/NetworkLog.h"
 #include "platform/weborigin/KnownPorts.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebInsecureRequestPolicy.h"
 #include "wtf/Assertions.h"
 #include "wtf/HashSet.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
@@ skipping 213 matching lines @@
     if (exceptionState.hadException())
         return nullptr;
 
     return webSocket;
 }
 
 void DOMWebSocket::connect(const String& url, const Vector<String>& protocols, ExceptionState& exceptionState)
 {
     UseCounter::count(getExecutionContext(), UseCounter::WebSocket);
 
-    WTF_LOG(Network, "WebSocket %p connect() url='%s'", this, url.utf8().data());
+    NETWORK_DVLOG(1) << "WebSocket " << this << " connect() url=" << url;
     m_url = KURL(KURL(), url);
 
     if (getExecutionContext()->securityContext().getInsecureRequestPolicy() & kUpgradeInsecureRequests && m_url.protocol() == "ws") {
         UseCounter::count(getExecutionContext(), UseCounter::UpgradeInsecureRequestsUpgradedRequest);
         m_url.setProtocol("wss");
         if (m_url.port() == 80)
             m_url.setPort(443);
     }
 
     if (!m_url.isValid()) {
@@ skipping 65 matching lines @@
     m_bufferedAmountAfterClose += payloadSize;
 
     logError("WebSocket is already in CLOSING or CLOSED state.");
 }
 
 void DOMWebSocket::reflectBufferedAmountConsumption(TimerBase*)
 {
     ASSERT(m_bufferedAmount >= m_consumedBufferedAmount);
     // Cast to unsigned long long is required since clang doesn't accept
     // combination of %llu and uint64_t (known as unsigned long).
-    WTF_LOG(Network, "WebSocket %p reflectBufferedAmountConsumption() %llu => %llu", this, static_cast<unsigned long long>(m_bufferedAmount), static_cast<unsigned long long>(m_bufferedAmount - m_consumedBufferedAmount));
+    NETWORK_DVLOG(1) << "WebSocket " << this << " reflectBufferedAmountConsumption() " << m_bufferedAmount << " => " << (m_bufferedAmount - m_consumedBufferedAmount);
 
     m_bufferedAmount -= m_consumedBufferedAmount;
     m_consumedBufferedAmount = 0;
 }
 
 void DOMWebSocket::releaseChannel()
 {
     ASSERT(m_channel);
     m_channel->disconnect();
     m_channel = nullptr;
 }
 
 void DOMWebSocket::logBinaryTypeChangesAfterOpen()
 {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, binaryTypeChangesHistogram, new CustomCountHistogram("WebCore.WebSocket.BinaryTypeChangesAfterOpen", 1, 1024, 10));
     DVLOG(3) << "WebSocket " << static_cast<void*>(this) << " logBinaryTypeChangesAfterOpen() logging " << m_binaryTypeChangesAfterOpen;
     binaryTypeChangesHistogram.count(m_binaryTypeChangesAfterOpen);
 }
 
 void DOMWebSocket::send(const String& message, ExceptionState& exceptionState)
 {
     CString encodedMessage = message.utf8();
 
-    WTF_LOG(Network, "WebSocket %p send() Sending String '%s'", this, encodedMessage.data());
+    NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending String " << message;
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     // No exception is raised if the connection was once established but has subsequently been closed.
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(encodedMessage.length());
         return;
     }
 
     recordSendTypeHistogram(WebSocketSendTypeString);
 
     ASSERT(m_channel);
     m_bufferedAmount += encodedMessage.length();
     m_channel->send(encodedMessage);
 }
 
 void DOMWebSocket::send(DOMArrayBuffer* binaryData, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "WebSocket %p send() Sending ArrayBuffer %p", this, binaryData);
+    NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending ArrayBuffer " << binaryData;
     ASSERT(binaryData && binaryData->buffer());
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(binaryData->byteLength());
         return;
     }
     recordSendTypeHistogram(WebSocketSendTypeArrayBuffer);
     recordSendMessageSizeHistogram(WebSocketSendTypeArrayBuffer, binaryData->byteLength());
     ASSERT(m_channel);
     m_bufferedAmount += binaryData->byteLength();
     m_channel->send(*binaryData, 0, binaryData->byteLength());
 }
 
 void DOMWebSocket::send(DOMArrayBufferView* arrayBufferView, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "WebSocket %p send() Sending ArrayBufferView %p", this, arrayBufferView);
+    NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending ArrayBufferView " << arrayBufferView;
     ASSERT(arrayBufferView);
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(arrayBufferView->byteLength());
         return;
     }
     recordSendTypeHistogram(WebSocketSendTypeArrayBufferView);
     recordSendMessageSizeHistogram(WebSocketSendTypeArrayBufferView, arrayBufferView->byteLength());
     ASSERT(m_channel);
     m_bufferedAmount += arrayBufferView->byteLength();
     m_channel->send(*arrayBufferView->buffer(), arrayBufferView->byteOffset(), arrayBufferView->byteLength());
 }
 
 void DOMWebSocket::send(Blob* binaryData, ExceptionState& exceptionState)
 {
-    WTF_LOG(Network, "WebSocket %p send() Sending Blob '%s'", this, binaryData->uuid().utf8().data());
+    NETWORK_DVLOG(1) << "WebSocket " << this << " send() Sending Blob " << binaryData->uuid();
     ASSERT(binaryData);
     if (m_state == kConnecting) {
         setInvalidStateErrorForSendMethod(exceptionState);
         return;
     }
     if (m_state == kClosing || m_state == kClosed) {
         updateBufferedAmountAfterClose(binaryData->size());
         return;
     }
     unsigned long long size = binaryData->size();
@@ skipping 23 matching lines @@
 
 void DOMWebSocket::close(unsigned short code, ExceptionState& exceptionState)
 {
     closeInternal(code, String(), exceptionState);
 }
 
 void DOMWebSocket::closeInternal(int code, const String& reason, ExceptionState& exceptionState)
 {
     String cleansedReason = reason;
     if (code == WebSocketChannel::CloseEventCodeNotSpecified) {
-        WTF_LOG(Network, "WebSocket %p close() without code and reason", this);
+        NETWORK_DVLOG(1) << "WebSocket " << this << " close() without code and reason";
     } else {
-        WTF_LOG(Network, "WebSocket %p close() code=%d reason='%s'", this, code, reason.utf8().data());
+        NETWORK_DVLOG(1) << "WebSocket " << this << " close() code=" << code << " reason=" << reason;
         if (!(code == WebSocketChannel::CloseEventCodeNormalClosure || (WebSocketChannel::CloseEventCodeMinimumUserDefined <= code && code <= WebSocketChannel::CloseEventCodeMaximumUserDefined))) {
             exceptionState.throwDOMException(InvalidAccessError, "The code must be either 1000, or between 3000 and 4999. " + String::number(code) + " is neither.");
             return;
         }
         // Bindings specify USVString, so unpaired surrogates are already replaced with U+FFFD.
         CString utf8 = reason.utf8();
         if (utf8.length() > maxReasonSizeInBytes) {
             exceptionState.throwDOMException(SyntaxError, "The message must not be greater than " + String::number(maxReasonSizeInBytes) + " bytes.");
             return;
         }
@@ skipping 85 matching lines @@
     return EventTargetNames::DOMWebSocket;
 }
 
 ExecutionContext* DOMWebSocket::getExecutionContext() const
 {
     return ActiveDOMObject::getExecutionContext();
 }
 
 void DOMWebSocket::contextDestroyed()
 {
-    WTF_LOG(Network, "WebSocket %p contextDestroyed()", this);
+    NETWORK_DVLOG(1) << "WebSocket " << this << " contextDestroyed()";
     DCHECK(!m_channel);
     DCHECK_EQ(kClosed, m_state);
     ActiveDOMObject::contextDestroyed();
 }
 
 bool DOMWebSocket::hasPendingActivity() const
 {
     return m_channel || !m_eventQueue->isEmpty();
 }
 
@@ skipping 15 matching lines @@
         releaseChannel();
     }
     if (m_state != kClosed) {
         m_state = kClosed;
         logBinaryTypeChangesAfterOpen();
     }
 }
 
 void DOMWebSocket::didConnect(const String& subprotocol, const String& extensions)
 {
-    WTF_LOG(Network, "WebSocket %p didConnect()", this);
+    NETWORK_DVLOG(1) << "WebSocket " << this << " didConnect()";
     if (m_state != kConnecting)
         return;
     m_state = kOpen;
     m_subprotocol = subprotocol;
     m_extensions = extensions;
     m_eventQueue->dispatch(Event::create(EventTypeNames::open));
 }
 
 void DOMWebSocket::didReceiveTextMessage(const String& msg)
 {
-    WTF_LOG(Network, "WebSocket %p didReceiveTextMessage() Text message '%s'", this, msg.utf8().data());
+    NETWORK_DVLOG(1) << "WebSocket " << this << " didReceiveTextMessage() Text message " << msg;
     if (m_state != kOpen)
         return;
     recordReceiveTypeHistogram(WebSocketReceiveTypeString);
 
     m_eventQueue->dispatch(MessageEvent::create(msg, SecurityOrigin::create(m_url)->toString()));
 }
 
 void DOMWebSocket::didReceiveBinaryMessage(std::unique_ptr<Vector<char>> binaryData)
 {
-    WTF_LOG(Network, "WebSocket %p didReceiveBinaryMessage() %lu byte binary message", this, static_cast<unsigned long>(binaryData->size()));
+    NETWORK_DVLOG(1) << "WebSocket " << this << " didReceiveBinaryMessage() " << binaryData->size() << " byte binary message";
     switch (m_binaryType) {
     case BinaryTypeBlob: {
         size_t size = binaryData->size();
         RefPtr<RawData> rawData = RawData::create();
         binaryData->swap(*rawData->mutableData());
         std::unique_ptr<BlobData> blobData = BlobData::create();
         blobData->appendData(rawData.release(), 0, BlobDataItem::toEndOfFile);
         Blob* blob = Blob::create(BlobDataHandle::create(std::move(blobData), size));
         recordReceiveTypeHistogram(WebSocketReceiveTypeBlob);
         recordReceiveMessageSizeHistogram(WebSocketReceiveTypeBlob, size);
         m_eventQueue->dispatch(MessageEvent::create(blob, SecurityOrigin::create(m_url)->toString()));
         break;
     }
 
     case BinaryTypeArrayBuffer:
         DOMArrayBuffer* arrayBuffer = DOMArrayBuffer::create(binaryData->data(), binaryData->size());
         recordReceiveTypeHistogram(WebSocketReceiveTypeArrayBuffer);
         recordReceiveMessageSizeHistogram(WebSocketReceiveTypeArrayBuffer, binaryData->size());
         m_eventQueue->dispatch(MessageEvent::create(arrayBuffer, SecurityOrigin::create(m_url)->toString()));
         break;
     }
 }
 
 void DOMWebSocket::didError()
 {
-    WTF_LOG(Network, "WebSocket %p didError()", this);
+    NETWORK_DVLOG(1) << "WebSocket " << this << " didError()";
     m_state = kClosed;
     logBinaryTypeChangesAfterOpen();
     m_eventQueue->dispatch(Event::create(EventTypeNames::error));
 }
 
 void DOMWebSocket::didConsumeBufferedAmount(uint64_t consumed)
 {
     ASSERT(m_bufferedAmount >= consumed + m_consumedBufferedAmount);
-    // Cast to unsigned long long is required since clang doesn't accept
-    // combination of %llu and uint64_t (known as unsigned long).
-    WTF_LOG(Network, "WebSocket %p didConsumeBufferedAmount(%llu)", this, static_cast<unsigned long long>(consumed));
+    NETWORK_DVLOG(1) << "WebSocket " << this << " didConsumeBufferedAmount(" << consumed << ")";
     if (m_state == kClosed)
         return;
     m_consumedBufferedAmount += consumed;
     if (!m_bufferedAmountConsumeTimer.isActive())
         m_bufferedAmountConsumeTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void DOMWebSocket::didStartClosingHandshake()
 {
-    WTF_LOG(Network, "WebSocket %p didStartClosingHandshake()", this);
+    NETWORK_DVLOG(1) << "WebSocket " << this << " didStartClosingHandshake()";
     m_state = kClosing;
 }
 
 void DOMWebSocket::didClose(ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
 {
-    WTF_LOG(Network, "WebSocket %p didClose()", this);
+    NETWORK_DVLOG(1) << "WebSocket " << this << " didClose()";
     if (!m_channel)
         return;
     bool allDataHasBeenConsumed = m_bufferedAmount == m_consumedBufferedAmount;
     bool wasClean = m_state == kClosing && allDataHasBeenConsumed && closingHandshakeCompletion == ClosingHandshakeComplete && code != WebSocketChannel::CloseEventCodeAbnormalClosure;
     m_state = kClosed;
 
     m_eventQueue->dispatch(CloseEvent::create(wasClean, code, reason));
     releaseChannel();
 }
 
@@ skipping 62 matching lines @@
 DEFINE_TRACE(DOMWebSocket)
 {
     visitor->trace(m_channel);
     visitor->trace(m_eventQueue);
     WebSocketChannelClient::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink