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

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

 /*
  * Copyright (C) 2013 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 27 matching lines @@
 #include "core/fileapi/FileReaderLoaderClient.h"
 #include "core/frame/LocalFrame.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/MixedContentChecker.h"
 #include "modules/websockets/InspectorWebSocketEvents.h"
 #include "modules/websockets/WebSocketChannelClient.h"
 #include "modules/websockets/WebSocketFrame.h"
-#include "platform/Logging.h"
+#include "platform/network/NetworkLog.h"
 #include "platform/network/WebSocketHandshakeRequest.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/websockets/WebSocketHandshakeRequestInfo.h"
 #include "public/platform/modules/websockets/WebSocketHandshakeResponseInfo.h"
 #include "wtf/PtrUtil.h"
@@ skipping 87 matching lines @@
 {
 }
 
 DocumentWebSocketChannel::~DocumentWebSocketChannel()
 {
     ASSERT(!m_blobLoader);
 }
 
 bool DocumentWebSocketChannel::connect(const KURL& url, const String& protocol)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p connect()", this);
+    NETWORK_DVLOG(1) << this << " connect()";
     if (!m_handle)
         return false;
 
     if (document()->frame()) {
         if (MixedContentChecker::shouldBlockWebSocket(document()->frame(), url))
             return false;
     }
     if (MixedContentChecker::isMixedContent(document()->getSecurityOrigin(), url)) {
         String message = "Connecting to a non-secure WebSocket server from a secure origin is deprecated.";
         document()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
@@ skipping 18 matching lines @@
     m_handle->connect(url, webProtocols, WebSecurityOrigin(getExecutionContext()->getSecurityOrigin()), document()->firstPartyForCookies(), document()->userAgent(), this);
 
     flowControlIfNecessary();
     TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketCreate", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketCreateEvent::data(document(), m_identifier, url, protocol));
     InspectorInstrumentation::didCreateWebSocket(document(), m_identifier, url, protocol);
     return true;
 }
 
 void DocumentWebSocketChannel::send(const CString& message)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p sendText(%s)", this, message.data());
+    NETWORK_DVLOG(1) << this << " sendText(" << message.data() << ")";
     // FIXME: Change the inspector API to show the entire message instead
     // of individual frames.
     InspectorInstrumentation::didSendWebSocketFrame(document(), m_identifier, WebSocketFrame::OpCodeText, true, message.data(), message.length());
     m_messages.append(new Message(message));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::send(PassRefPtr<BlobDataHandle> blobDataHandle)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p sendBlob(%s, %s, %llu)", this, blobDataHandle->uuid().utf8().data(), blobDataHandle->type().utf8().data(), blobDataHandle->size());
+    NETWORK_DVLOG(1) << this << " sendBlob(" << blobDataHandle->uuid() << ", " << blobDataHandle->type() << ", " << blobDataHandle->size() << ")";
     // FIXME: Change the inspector API to show the entire message instead
     // of individual frames.
     // FIXME: We can't access the data here.
     // Since Binary data are not displayed in Inspector, this does not
     // affect actual behavior.
     InspectorInstrumentation::didSendWebSocketFrame(document(), m_identifier, WebSocketFrame::OpCodeBinary, true, "", 0);
     m_messages.append(new Message(blobDataHandle));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::send(const DOMArrayBuffer& buffer, unsigned byteOffset, unsigned byteLength)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p sendArrayBuffer(%p, %u, %u)", this, buffer.data(), byteOffset, byteLength);
+    NETWORK_DVLOG(1) << this << " sendArrayBuffer(" << buffer.data() << ", " << byteOffset << ", " << byteLength << ")";
     // FIXME: Change the inspector API to show the entire message instead
     // of individual frames.
     InspectorInstrumentation::didSendWebSocketFrame(document(), m_identifier, WebSocketFrame::OpCodeBinary, true, static_cast<const char*>(buffer.data()) + byteOffset, byteLength);
     // buffer.slice copies its contents.
     // FIXME: Reduce copy by sending the data immediately when we don't need to
     // queue the data.
     m_messages.append(new Message(buffer.slice(byteOffset, byteOffset + byteLength)));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::sendTextAsCharVector(std::unique_ptr<Vector<char>> data)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p sendTextAsCharVector(%p, %llu)", this, data.get(), static_cast<unsigned long long>(data->size()));
+    NETWORK_DVLOG(1) << this << " sendTextAsCharVector(" << static_cast<void*>(data.get()) << ", " << data->size() << ")";
     // FIXME: Change the inspector API to show the entire message instead
     // of individual frames.
     InspectorInstrumentation::didSendWebSocketFrame(document(), m_identifier, WebSocketFrame::OpCodeText, true, data->data(), data->size());
     m_messages.append(new Message(std::move(data), MessageTypeTextAsCharVector));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::sendBinaryAsCharVector(std::unique_ptr<Vector<char>> data)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p sendBinaryAsCharVector(%p, %llu)", this, data.get(), static_cast<unsigned long long>(data->size()));
+    NETWORK_DVLOG(1) << this << " sendBinaryAsCharVector(" << static_cast<void*>(data.get()) << ", " << data->size() << ")";
     // FIXME: Change the inspector API to show the entire message instead
     // of individual frames.
     InspectorInstrumentation::didSendWebSocketFrame(document(), m_identifier, WebSocketFrame::OpCodeBinary, true, data->data(), data->size());
     m_messages.append(new Message(std::move(data), MessageTypeBinaryAsCharVector));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::close(int code, const String& reason)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p close(%d, %s)", this, code, reason.utf8().data());
+    NETWORK_DVLOG(1) << this << " close(" << code << ", " << reason << ")";
     ASSERT(m_handle);
     unsigned short codeToSend = static_cast<unsigned short>(code == CloseEventCodeNotSpecified ? CloseEventCodeNoStatusRcvd : code);
     m_messages.append(new Message(codeToSend, reason));
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::fail(const String& reason, MessageLevel level, std::unique_ptr<SourceLocation> location)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p fail(%s)", this, reason.utf8().data());
+    NETWORK_DVLOG(1) << this << " fail(" << reason << ")";
     // m_handle and m_client can be null here.
 
     InspectorInstrumentation::didReceiveWebSocketFrameError(document(), m_identifier, reason);
     const String message = "WebSocket connection to '" + m_url.elidedString() + "' failed: " + reason;
     getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, level, message, std::move(location)));
 
     if (m_client)
         m_client->didError();
     // |reason| is only for logging and should not be provided for scripts,
     // hence close reason must be empty.
     handleDidClose(false, CloseEventCodeAbnormalClosure, String());
     // handleDidClose may delete this object.
 }
 
 void DocumentWebSocketChannel::disconnect()
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p disconnect()", this);
+    NETWORK_DVLOG(1) << this << " disconnect()";
     if (m_identifier) {
         TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketDestroy", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketEvent::data(document(), m_identifier));
         InspectorInstrumentation::didCloseWebSocket(document(), m_identifier);
     }
     abortAsyncOperations();
     m_handle.reset();
     m_client = nullptr;
     m_identifier = 0;
 }
 
@@ skipping 118 matching lines @@
 Document* DocumentWebSocketChannel::document()
 {
     // This context is always a Document. See the constructor.
     ExecutionContext* context = getExecutionContext();
     ASSERT(context->isDocument());
     return toDocument(context);
 }
 
 void DocumentWebSocketChannel::didConnect(WebSocketHandle* handle, const WebString& selectedProtocol, const WebString& extensions)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didConnect(%p, %s, %s)", this, handle, selectedProtocol.utf8().c_str(), extensions.utf8().c_str());
+    NETWORK_DVLOG(1) << this << " didConnect(" << handle << ", " << String(selectedProtocol) << ", " << String(extensions) << ")";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
     ASSERT(m_client);
 
     m_client->didConnect(selectedProtocol, extensions);
 }
 
 void DocumentWebSocketChannel::didStartOpeningHandshake(WebSocketHandle* handle, const WebSocketHandshakeRequestInfo& request)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didStartOpeningHandshake(%p)", this, handle);
+    NETWORK_DVLOG(1) << this << " didStartOpeningHandshake(" << handle << ")";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
 
     TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketSendHandshakeRequest", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketEvent::data(document(), m_identifier));
     InspectorInstrumentation::willSendWebSocketHandshakeRequest(document(), m_identifier, &request.toCoreRequest());
     m_handshakeRequest = WebSocketHandshakeRequest::create(request.toCoreRequest());
 }
 
 void DocumentWebSocketChannel::didFinishOpeningHandshake(WebSocketHandle* handle, const WebSocketHandshakeResponseInfo& response)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didFinishOpeningHandshake(%p)", this, handle);
+    NETWORK_DVLOG(1) << this << " didFinishOpeningHandshake(" << handle << ")";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
 
     TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketReceiveHandshakeResponse", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketEvent::data(document(), m_identifier));
     InspectorInstrumentation::didReceiveWebSocketHandshakeResponse(document(), m_identifier, m_handshakeRequest.get(), &response.toCoreResponse());
     m_handshakeRequest.clear();
 }
 
 void DocumentWebSocketChannel::didFail(WebSocketHandle* handle, const WebString& message)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didFail(%p, %s)", this, handle, message.utf8().data());
+    NETWORK_DVLOG(1) << this << " didFail(" << handle << ", " << String(message) << ")";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
 
     // This function is called when the browser is required to fail the
     // WebSocketConnection. Hence we fail this channel by calling
     // |this->failAsError| function.
     failAsError(message);
     // |this| may be deleted.
 }
 
 void DocumentWebSocketChannel::didReceiveData(WebSocketHandle* handle, bool fin, WebSocketHandle::MessageType type, const char* data, size_t size)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didReceiveData(%p, %d, %d, (%p, %zu))", this, handle, fin, type, data, size);
+    NETWORK_DVLOG(1) << this << " didReceiveData(" << handle << ", " << fin << ", " << type << ", (" << static_cast<const void*>(data) << ", " << size << "))";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
     ASSERT(m_client);
     // Non-final frames cannot be empty.
     ASSERT(fin || size);
 
     switch (type) {
     case WebSocketHandle::MessageTypeText:
         ASSERT(m_receivingMessageData.isEmpty());
@@ skipping 30 matching lines @@
         }
     } else {
         std::unique_ptr<Vector<char>> binaryData = wrapUnique(new Vector<char>);
         binaryData->swap(m_receivingMessageData);
         m_client->didReceiveBinaryMessage(std::move(binaryData));
     }
 }
 
 void DocumentWebSocketChannel::didClose(WebSocketHandle* handle, bool wasClean, unsigned short code, const WebString& reason)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didClose(%p, %d, %u, %s)", this, handle, wasClean, code, String(reason).utf8().data());
+    NETWORK_DVLOG(1) << this << " didClose(" << handle << ", " << wasClean << ", " << code << ", " << String(reason) << ")";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
 
     m_handle.reset();
 
     if (m_identifier) {
         TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketDestroy", TRACE_EVENT_SCOPE_THREAD, "data", InspectorWebSocketEvent::data(document(), m_identifier));
         InspectorInstrumentation::didCloseWebSocket(document(), m_identifier);
         m_identifier = 0;
     }
 
     handleDidClose(wasClean, code, reason);
     // handleDidClose may delete this object.
 }
 
 void DocumentWebSocketChannel::didReceiveFlowControl(WebSocketHandle* handle, int64_t quota)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didReceiveFlowControl(%p, %ld)", this, handle, static_cast<long>(quota));
+    NETWORK_DVLOG(1) << this << " didReceiveFlowControl(" << handle << ", " << quota << ")";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
     ASSERT(quota >= 0);
 
     m_sendingQuota += quota;
     processSendQueue();
 }
 
 void DocumentWebSocketChannel::didStartClosingHandshake(WebSocketHandle* handle)
 {
-    WTF_LOG(Network, "DocumentWebSocketChannel %p didStartClosingHandshake(%p)", this, handle);
+    NETWORK_DVLOG(1) << this << " didStartClosingHandshake(" << handle << ")";
 
     ASSERT(m_handle);
     ASSERT(handle == m_handle.get());
 
     if (m_client)
         m_client->didStartClosingHandshake();
 }
 
 void DocumentWebSocketChannel::didFinishLoadingBlob(DOMArrayBuffer* buffer)
 {
@@ skipping 20 matching lines @@
 
 DEFINE_TRACE(DocumentWebSocketChannel)
 {
     visitor->trace(m_blobLoader);
     visitor->trace(m_messages);
     visitor->trace(m_client);
     WebSocketChannel::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
+std::ostream& operator<<(std::ostream& ostream, const DocumentWebSocketChannel* channel)
+{
+    return ostream << "DocumentWebSocketChannel " << static_cast<const void*>(channel);
+}
+
 } // namespace blink