Make websocket error messages look better at the devtools console.

Source/modules/websockets/MainThreadWebSocketChannel.cpp

 /*
  * Copyright (C) 2011, 2012 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 76 matching lines @@
     , m_hasContinuousFrame(false)
     , m_closeEventCode(CloseEventCodeAbnormalClosure)
     , m_outgoingFrameQueueStatus(OutgoingFrameQueueOpen)
     , m_blobLoaderStatus(BlobLoaderNotStarted)
     , m_callFrameAtConnection("", "", 0)
 {
     if (Page* page = m_document->page())
         m_identifier = createUniqueIdentifier();
 }
 
+MainThreadWebSocketChannel::MainThreadWebSocketChannel(Document* document, WebSocketChannelClient* client, const ScriptCallFrame& callFrame)
+    : m_document(document)
+    , m_client(client)
+    , m_resumeTimer(this, &MainThreadWebSocketChannel::resumeTimerFired)
+    , m_suspended(false)
+    , m_closing(false)
+    , m_didFailOfClientAlreadyRun(false)
+    , m_receivedClosingHandshake(false)
+    , m_closingTimer(this, &MainThreadWebSocketChannel::closingTimerFired)
+    , m_closed(false)
+    , m_shouldDiscardReceivedData(false)
+    , m_unhandledBufferedAmount(0)
+    , m_identifier(0)
+    , m_hasContinuousFrame(false)
+    , m_closeEventCode(CloseEventCodeAbnormalClosure)
+    , m_outgoingFrameQueueStatus(OutgoingFrameQueueOpen)
+    , m_blobLoaderStatus(BlobLoaderNotStarted)
+    , m_callFrameAtConnection(callFrame)
+{
+    if (Page* page = m_document->page())
+        m_identifier = createUniqueIdentifier();
+}
+
 MainThreadWebSocketChannel::~MainThreadWebSocketChannel()
 {
 }
 
 void MainThreadWebSocketChannel::connect(const KURL& url, const String& protocol)
 {
     LOG(Network, "MainThreadWebSocketChannel %p connect()", this);
     ASSERT(!m_handle);
     ASSERT(!m_suspended);
     m_handshake = adoptPtr(new WebSocketHandshake(url, protocol, m_document));
     m_handshake->reset();
     m_handshake->addExtensionProcessor(m_deflateFramer.createExtensionProcessor());
     if (m_identifier)
         InspectorInstrumentation::didCreateWebSocket(m_document, m_identifier, url, m_document->url(), protocol);
     ref();
     m_handle = SocketStreamHandle::create(m_handshake->url(), this);
-    RefPtr<ScriptCallStack> callstack = createScriptCallStack(1, true);
-    m_callFrameAtConnection = callstack && callstack->size() > 0 ? callstack->at(0) : ScriptCallFrame("", "", 0);
+    RefPtr<ScriptCallStack> callStack = createScriptCallStack(1, true);
+    if (callStack && callStack->size() > 0)
+        m_callFrameAtConnection = callStack->at(0);
 }
 
 String MainThreadWebSocketChannel::subprotocol()
 {
     LOG(Network, "MainThreadWebSocketChannel %p subprotocol()", this);
     if (!m_handshake || m_handshake->mode() != WebSocketHandshake::Connected)
         return "";
     String serverProtocol = m_handshake->serverWebSocketProtocol();
     if (serverProtocol.isNull())
         return "";
@@ skipping 62 matching lines @@
 {
     LOG(Network, "MainThreadWebSocketChannel %p close() code=%d reason='%s'", this, code, reason.utf8().data());
     ASSERT(!m_suspended);
     if (!m_handle)
         return;
     startClosingHandshake(code, reason);
     if (m_closing && !m_closingTimer.isActive())
         m_closingTimer.startOneShot(2 * TCPMaximumSegmentLifetime);
 }
 
-void MainThreadWebSocketChannel::fail(const String& reason)
+void MainThreadWebSocketChannel::fail(const String& reason, MessageLevel level)
+{
+    fail(reason, level, 0);
+}
+
+void MainThreadWebSocketChannel::fail(const String& reason, MessageLevel level, PassOwnPtr<CallStackWrapper> wrapper)
 {
     LOG(Network, "MainThreadWebSocketChannel %p fail() reason='%s'", this, reason.utf8().data());
     ASSERT(!m_suspended);
     if (m_document) {
         InspectorInstrumentation::didReceiveWebSocketFrameError(m_document, m_identifier, reason);
         const String message = "WebSocket connection to '" + m_handshake->url().elidedString() + "' failed: " + reason;
-        RefPtr<ScriptCallStack> callstack = createScriptCallStack(1, true);
-        if (callstack && callstack->size() > 0) {
-            // We are in a JS callstack.
-            // So, the addConsoleMessage method will show the stack appropriately.
-            m_document->addConsoleMessage(JSMessageSource, ErrorMessageLevel, message);
+        RefPtr<ScriptCallStack> callStack = wrapper ? wrapper->callStack() : adoptRef<ScriptCallStack>(0);

[Use mkwst_at_chromium.org plz., 2013/05/01 14:55:02]

Can't you just return 0 in the second case?

[yhirano, 2013/05/02 02:33:01]

Done.

+        if (callStack && callStack->size() > 0) {
+            String url = callStack->at(0).sourceURL();
+            unsigned lineNumber = callStack->at(0).lineNumber();
+            static_cast<ScriptExecutionContext*>(m_document)->addConsoleMessage(JSMessageSource, level, message, url, lineNumber);

[Use mkwst_at_chromium.org plz., 2013/05/01 14:55:02]

You shouldn't need this cast: Document subclasses ScriptExcutionContext.

[yhirano, 2013/05/02 02:33:01]

Document::addConsoleMessage(shorter one) hides
ScriptExecutionContext::addConsoleMessage(longer one).
Maybe Document class should expose addConsoleMessage(longer one) explicitely.

         } else {
-            // We are not in a JS callstack.
-            // Then show the source file and the line number at the connection initiation.
-            const String& url = m_callFrameAtConnection.sourceURL();
-            unsigned lineNumber = m_callFrameAtConnection.lineNumber();
-            static_cast<ScriptExecutionContext*>(m_document)->addConsoleMessage(JSMessageSource, ErrorMessageLevel, message, url, lineNumber, 0, 0);
+            RefPtr<ScriptCallStack> callStack = createScriptCallStack(1, true);
+            if (callStack && callStack->size() > 0) {
+                // We are in a JS callstack.

[Use mkwst_at_chromium.org plz., 2013/05/01 14:55:02]

I believe you can always take the second branch: this logic is more or less
replicated inside ConsoleMessage::autogenerateMetadata. If a callstack can be
generated, it will be used. Otherwise, the line number and URL you provide will
be used.

Do you see different results in the output? It's difficult to tell which test is
testing this branch.

[yhirano, 2013/05/02 02:33:01]

You are right, but I would like to fix this in another CL. Some layout tests
will be affected by the change although no actual behavior change will be
introduced.

+                // So, the addConsoleMessage method will show the stack appropriately.
+                m_document->addConsoleMessage(JSMessageSource, level, message);
+            } else {
+                // We are not in a JS callstack.
+                // Then show the source file and the line number at the connection initiation.
+                const String& url = m_callFrameAtConnection.sourceURL();
+                unsigned lineNumber = m_callFrameAtConnection.lineNumber();
+                static_cast<ScriptExecutionContext*>(m_document)->addConsoleMessage(JSMessageSource, level, message, url, lineNumber, 0, 0);

[tyoshino (SeeGerritForStatus), 2013/05/01 11:41:52]

remove ", 0, 0" here too?

[yhirano, 2013/05/02 02:04:58]

Done.

+            }
         }
     }
+    failInternal();
+}
 
+void MainThreadWebSocketChannel::failInternal()
+{
     // Hybi-10 specification explicitly states we must not continue to handle incoming data
     // once the WebSocket connection is failed (section 7.1.7).
     RefPtr<MainThreadWebSocketChannel> protect(this); // The client can close the channel, potentially removing the last reference.
     m_shouldDiscardReceivedData = true;
     if (!m_buffer.isEmpty())
         skipBuffer(m_buffer.size()); // Save memory.
     m_deflateFramer.didFail();
     m_hasContinuousFrame = false;
     m_continuousFrameData.clear();
     if (!m_didFailOfClientAlreadyRun) {
@@ skipping 41 matching lines @@
 void MainThreadWebSocketChannel::didOpenSocketStream(SocketStreamHandle* handle)
 {
     LOG(Network, "MainThreadWebSocketChannel %p didOpenSocketStream()", this);
     ASSERT(handle == m_handle);
     if (!m_document)
         return;
     if (m_identifier)
         InspectorInstrumentation::willSendWebSocketHandshakeRequest(m_document, m_identifier, *m_handshake->clientHandshakeRequest());
     CString handshakeMessage = m_handshake->clientHandshakeMessage();
     if (!handle->send(handshakeMessage.data(), handshakeMessage.length()))
-        fail("Failed to send WebSocket handshake.");
+        failAsError("Failed to send WebSocket handshake.");
 }
 
 void MainThreadWebSocketChannel::didCloseSocketStream(SocketStreamHandle* handle)
 {
     LOG(Network, "MainThreadWebSocketChannel %p didCloseSocketStream()", this);
     if (m_identifier && m_document)
         InspectorInstrumentation::didCloseWebSocket(m_document, m_identifier);
     ASSERT_UNUSED(handle, handle == m_handle || !m_handle);
     m_closed = true;
     if (m_closingTimer.isActive())
@@ skipping 27 matching lines @@
     }
     if (!m_client) {
         m_shouldDiscardReceivedData = true;
         handle->disconnect();
         return;
     }
     if (m_shouldDiscardReceivedData)
         return;
     if (!appendToBuffer(data, len)) {
         m_shouldDiscardReceivedData = true;
-        fail("Ran out of memory while receiving WebSocket data.");
+        failAsError("Ran out of memory while receiving WebSocket data.");
         return;
     }
     while (!m_suspended && m_client && !m_buffer.isEmpty())
         if (!processBuffer())
             break;
 }
 
 void MainThreadWebSocketChannel::didUpdateBufferedAmount(SocketStreamHandle*, size_t bufferedAmount)
 {
     if (m_client)
@@ skipping 50 matching lines @@
     deref();
 }
 
 void MainThreadWebSocketChannel::didFail(int errorCode)
 {
     LOG(Network, "MainThreadWebSocketChannel %p didFail() errorCode=%d", this, errorCode);
     ASSERT(m_blobLoader);
     ASSERT(m_blobLoaderStatus == BlobLoaderStarted);
     m_blobLoader.clear();
     m_blobLoaderStatus = BlobLoaderFailed;
-    fail("Failed to load Blob: error code = " + String::number(errorCode)); // FIXME: Generate human-friendly reason message.
+    failAsError("Failed to load Blob: error code = " + String::number(errorCode)); // FIXME: Generate human-friendly reason message.
     deref();
 }
 
 bool MainThreadWebSocketChannel::appendToBuffer(const char* data, size_t len)
 {
     size_t newBufferSize = m_buffer.size() + len;
     if (newBufferSize < m_buffer.size()) {
         LOG(Network, "MainThreadWebSocketChannel %p appendToBuffer() Buffer overflow (%lu bytes already in receive buffer and appending %lu bytes)", this, static_cast<unsigned long>(m_buffer.size()), static_cast<unsigned long>(len));
         return false;
     }
@@ skipping 42 matching lines @@
             LOG(Network, "MainThreadWebSocketChannel %p Connected", this);
             skipBuffer(headerLength);
             m_client->didConnect();
             LOG(Network, "MainThreadWebSocketChannel %p %lu bytes remaining in m_buffer", this, static_cast<unsigned long>(m_buffer.size()));
             return !m_buffer.isEmpty();
         }
         ASSERT(m_handshake->mode() == WebSocketHandshake::Failed);
         LOG(Network, "MainThreadWebSocketChannel %p Connection failed", this);
         skipBuffer(headerLength);
         m_shouldDiscardReceivedData = true;
-        fail(m_handshake->failureReason());
+        failAsError(m_handshake->failureReason());
         return false;
     }
     if (m_handshake->mode() != WebSocketHandshake::Connected)
         return false;
 
     return processFrame();
 }
 
 void MainThreadWebSocketChannel::resumeTimerFired(Timer<MainThreadWebSocketChannel>* timer)
 {
@@ skipping 43 matching lines @@
 {
     ASSERT(!m_buffer.isEmpty());
 
     WebSocketFrame frame;
     const char* frameEnd;
     String errorString;
     WebSocketFrame::ParseFrameResult result = WebSocketFrame::parseFrame(m_buffer.data(), m_buffer.size(), frame, frameEnd, errorString);
     if (result == WebSocketFrame::FrameIncomplete)
         return false;
     if (result == WebSocketFrame::FrameError) {
-        fail(errorString);
+        failAsError(errorString);
         return false;
     }
 
     ASSERT(m_buffer.data() < frameEnd);
     ASSERT(frameEnd <= m_buffer.data() + m_buffer.size());
 
     OwnPtr<InflateResultHolder> inflateResult = m_deflateFramer.inflate(frame);
     if (!inflateResult->succeeded()) {
-        fail(inflateResult->failureReason());
+        failAsError(inflateResult->failureReason());
         return false;
     }
 
     // Validate the frame data.
     if (WebSocketFrame::isReservedOpCode(frame.opCode)) {
-        fail("Unrecognized frame opcode: " + String::number(frame.opCode));
+        failAsError("Unrecognized frame opcode: " + String::number(frame.opCode));
         return false;
     }
 
     if (frame.reserved2 || frame.reserved3) {
-        fail("One or more reserved bits are on: reserved2 = " + String::number(frame.reserved2) + ", reserved3 = " + String::number(frame.reserved3));
+        failAsError("One or more reserved bits are on: reserved2 = " + String::number(frame.reserved2) + ", reserved3 = " + String::number(frame.reserved3));
         return false;
     }
 
     if (frame.masked) {
-        fail("A server must not mask any frames that it sends to the client.");
+        failAsError("A server must not mask any frames that it sends to the client.");
         return false;
     }
 
     // All control frames must not be fragmented.
     if (WebSocketFrame::isControlOpCode(frame.opCode) && !frame.final) {
-        fail("Received fragmented control frame: opcode = " + String::number(frame.opCode));
+        failAsError("Received fragmented control frame: opcode = " + String::number(frame.opCode));
         return false;
     }
 
     // All control frames must have a payload of 125 bytes or less, which means the frame must not contain
     // the "extended payload length" field.
     if (WebSocketFrame::isControlOpCode(frame.opCode) && WebSocketFrame::needsExtendedLengthField(frame.payloadLength)) {
-        fail("Received control frame having too long payload: " + String::number(frame.payloadLength) + " bytes");
+        failAsError("Received control frame having too long payload: " + String::number(frame.payloadLength) + " bytes");
         return false;
     }
 
     // A new data frame is received before the previous continuous frame finishes.
     // Note that control frames are allowed to come in the middle of continuous frames.
     if (m_hasContinuousFrame && frame.opCode != WebSocketFrame::OpCodeContinuation && !WebSocketFrame::isControlOpCode(frame.opCode)) {
-        fail("Received new data frame but previous continuous frame is unfinished.");
+        failAsError("Received new data frame but previous continuous frame is unfinished.");
         return false;
     }
 
     InspectorInstrumentation::didReceiveWebSocketFrame(m_document, m_identifier, frame);
 
     switch (frame.opCode) {
     case WebSocketFrame::OpCodeContinuation:
         // An unexpected continuation frame is received without any leading frame.
         if (!m_hasContinuousFrame) {
-            fail("Received unexpected continuation frame.");
+            failAsError("Received unexpected continuation frame.");
             return false;
         }
         m_continuousFrameData.append(frame.payload, frame.payloadLength);
         skipBuffer(frameEnd - m_buffer.data());
         if (frame.final) {
             // onmessage handler may eventually call the other methods of this channel,
             // so we should pretend that we have finished to read this frame and
             // make sure that the member variables are in a consistent state before
             // the handler is invoked.
             // Vector<char>::swap() is used here to clear m_continuousFrameData.
             OwnPtr<Vector<char> > continuousFrameData = adoptPtr(new Vector<char>);
             m_continuousFrameData.swap(*continuousFrameData);
             m_hasContinuousFrame = false;
             if (m_continuousFrameOpCode == WebSocketFrame::OpCodeText) {
                 String message;
                 if (continuousFrameData->size())
                     message = String::fromUTF8(continuousFrameData->data(), continuousFrameData->size());
                 else
                     message = "";
                 if (message.isNull())
-                    fail("Could not decode a text frame as UTF-8.");
+                    failAsError("Could not decode a text frame as UTF-8.");
                 else
                     m_client->didReceiveMessage(message);
             } else if (m_continuousFrameOpCode == WebSocketFrame::OpCodeBinary)
                 m_client->didReceiveBinaryData(continuousFrameData.release());
         }
         break;
 
     case WebSocketFrame::OpCodeText:
         if (frame.final) {
             String message;
             if (frame.payloadLength)
                 message = String::fromUTF8(frame.payload, frame.payloadLength);
             else
                 message = "";
             skipBuffer(frameEnd - m_buffer.data());
             if (message.isNull())
-                fail("Could not decode a text frame as UTF-8.");
+                failAsError("Could not decode a text frame as UTF-8.");
             else
                 m_client->didReceiveMessage(message);
         } else {
             m_hasContinuousFrame = true;
             m_continuousFrameOpCode = WebSocketFrame::OpCodeText;
             ASSERT(m_continuousFrameData.isEmpty());
             m_continuousFrameData.append(frame.payload, frame.payloadLength);
             skipBuffer(frameEnd - m_buffer.data());
         }
         break;
@@ skipping 11 matching lines @@
             m_continuousFrameData.append(frame.payload, frame.payloadLength);
             skipBuffer(frameEnd - m_buffer.data());
         }
         break;
 
     case WebSocketFrame::OpCodeClose:
         if (!frame.payloadLength)
             m_closeEventCode = CloseEventCodeNoStatusRcvd;
         else if (frame.payloadLength == 1) {
             m_closeEventCode = CloseEventCodeAbnormalClosure;
-            fail("Received a broken close frame containing an invalid size body.");
+            failAsError("Received a broken close frame containing an invalid size body.");
             return false;
         } else {
             unsigned char highByte = static_cast<unsigned char>(frame.payload[0]);
             unsigned char lowByte = static_cast<unsigned char>(frame.payload[1]);
             m_closeEventCode = highByte << 8 | lowByte;
             if (m_closeEventCode == CloseEventCodeNoStatusRcvd || m_closeEventCode == CloseEventCodeAbnormalClosure || m_closeEventCode == CloseEventCodeTLSHandshake) {
                 m_closeEventCode = CloseEventCodeAbnormalClosure;
-                fail("Received a broken close frame containing a reserved status code.");
+                failAsError("Received a broken close frame containing a reserved status code.");
                 return false;
             }
         }
         if (frame.payloadLength >= 3)
             m_closeEventReason = String::fromUTF8(&frame.payload[2], frame.payloadLength - 2);
         else
             m_closeEventReason = "";
         skipBuffer(frameEnd - m_buffer.data());
         m_receivedClosingHandshake = true;
         startClosingHandshake(m_closeEventCode, m_closeEventReason);
@@ skipping 59 matching lines @@
 void MainThreadWebSocketChannel::processOutgoingFrameQueue()
 {
     if (m_outgoingFrameQueueStatus == OutgoingFrameQueueClosed)
         return;
 
     while (!m_outgoingFrameQueue.isEmpty()) {
         OwnPtr<QueuedFrame> frame = m_outgoingFrameQueue.takeFirst();
         switch (frame->frameType) {
         case QueuedFrameTypeString: {
             if (!sendFrame(frame->opCode, frame->stringData.data(), frame->stringData.length()))
-                fail("Failed to send WebSocket frame.");
+                failAsError("Failed to send WebSocket frame.");
             break;
         }
 
         case QueuedFrameTypeVector:
             if (!sendFrame(frame->opCode, frame->vectorData.data(), frame->vectorData.size()))
-                fail("Failed to send WebSocket frame.");
+                failAsError("Failed to send WebSocket frame.");
             break;
 
         case QueuedFrameTypeBlob: {
             switch (m_blobLoaderStatus) {
             case BlobLoaderNotStarted:
                 ref(); // Will be derefed after didFinishLoading() or didFail().
                 ASSERT(!m_blobLoader);
                 m_blobLoader = adoptPtr(new FileReaderLoader(FileReaderLoader::ReadAsArrayBuffer, this));
                 m_blobLoaderStatus = BlobLoaderStarted;
                 m_blobLoader->start(m_document, frame->blobData.get());
                 m_outgoingFrameQueue.prepend(frame.release());
                 return;
 
             case BlobLoaderStarted:
             case BlobLoaderFailed:
                 m_outgoingFrameQueue.prepend(frame.release());
                 return;
 
             case BlobLoaderFinished: {
                 RefPtr<ArrayBuffer> result = m_blobLoader->arrayBufferResult();
                 m_blobLoader.clear();
                 m_blobLoaderStatus = BlobLoaderNotStarted;
                 if (!sendFrame(frame->opCode, static_cast<const char*>(result->data()), result->byteLength()))
-                    fail("Failed to send WebSocket frame.");
+                    failAsError("Failed to send WebSocket frame.");
                 break;
             }
             }
             break;
         }
 
         default:
             ASSERT_NOT_REACHED();
             break;
         }
@@ skipping 19 matching lines @@
 bool MainThreadWebSocketChannel::sendFrame(WebSocketFrame::OpCode opCode, const char* data, size_t dataLength)
 {
     ASSERT(m_handle);
     ASSERT(!m_suspended);
 
     WebSocketFrame frame(opCode, true, false, true, data, dataLength);
     InspectorInstrumentation::didSendWebSocketFrame(m_document, m_identifier, frame);
 
     OwnPtr<DeflateResultHolder> deflateResult = m_deflateFramer.deflate(frame);
     if (!deflateResult->succeeded()) {
-        fail(deflateResult->failureReason());
+        failAsError(deflateResult->failureReason());
         return false;
     }
 
     Vector<char> frameData;
     frame.makeFrameData(frameData);
 
     return m_handle->send(frameData.data(), frameData.size());
 }
 
 } // namespace WebCore