Make websocket error messages look better at the devtools console.

Source/modules/websockets/MainThreadWebSocketChannel.h

 /*
  * 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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef MainThreadWebSocketChannel_h
 #define MainThreadWebSocketChannel_h
 
 #include "core/fileapi/FileReaderLoaderClient.h"
 #include "core/inspector/ScriptCallFrame.h"
+#include "core/page/ConsoleTypes.h"
 #include "core/platform/Timer.h"
 #include "core/platform/network/SocketStreamHandleClient.h"
 #include "modules/websockets/WebSocketChannel.h"
 #include "modules/websockets/WebSocketDeflateFramer.h"
 #include "modules/websockets/WebSocketFrame.h"
 #include "modules/websockets/WebSocketHandshake.h"
 #include "wtf/Deque.h"
 #include "wtf/Forward.h"
+#include "wtf/PassOwnPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 
 namespace WebCore {
 
 class Blob;
 class Document;
 class FileReaderLoader;
 class SocketStreamHandle;
 class SocketStreamError;
 class WebSocketChannelClient;
 
 class MainThreadWebSocketChannel : public RefCounted<MainThreadWebSocketChannel>, public SocketStreamHandleClient, public WebSocketChannel
                                  , public FileReaderLoaderClient {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     static PassRefPtr<MainThreadWebSocketChannel> create(Document* document, WebSocketChannelClient* client) { return adoptRef(new MainThreadWebSocketChannel(document, client)); }
+    static PassRefPtr<MainThreadWebSocketChannel> create(Document* document, WebSocketChannelClient* client, const ScriptCallFrame& frame) { return adoptRef(new MainThreadWebSocketChannel(document, client, frame)); }
     virtual ~MainThreadWebSocketChannel();
 
     bool send(const char* data, int length);
 
     // WebSocketChannel functions.
     virtual void connect(const KURL&, const String& protocol) OVERRIDE;
     virtual String subprotocol() OVERRIDE;
     virtual String extensions() OVERRIDE;
     virtual WebSocketChannel::SendResult send(const String& message) OVERRIDE;
     virtual WebSocketChannel::SendResult send(const ArrayBuffer&, unsigned byteOffset, unsigned byteLength) OVERRIDE;
     virtual WebSocketChannel::SendResult send(const Blob&) OVERRIDE;
     virtual unsigned long bufferedAmount() const OVERRIDE;
     // Start closing handshake. Use the CloseEventCodeNotSpecified for the code
     // argument to omit payload.
     virtual void close(int code, const String& reason) OVERRIDE;
-    virtual void fail(const String& reason) OVERRIDE;
+    void fail(const String& reason) { fail(reason, ErrorMessageLevel); }

[tyoshino (SeeGerritForStatus), 2013/05/01 08:03:23]

how about renaming this to failAsError and make this private?

[yhirano, 2013/05/01 09:31:44]

Done.

+    virtual void fail(const String& reason, MessageLevel) OVERRIDE;
+    virtual void fail(const String& reason, MessageLevel, PassOwnPtr<CallStackWrapper>) OVERRIDE;

[tyoshino (SeeGerritForStatus), 2013/05/01 08:03:23]

Comment what this method is for.

[yhirano, 2013/05/01 09:31:44]

Wrote the method description in WebSocketChannel.h.

     virtual void disconnect() OVERRIDE;
 
     virtual void suspend() OVERRIDE;
     virtual void resume() OVERRIDE;
 
     // SocketStreamHandleClient functions.
     virtual void willOpenSocketStream(SocketStreamHandle*) OVERRIDE;
     virtual void didOpenSocketStream(SocketStreamHandle*) OVERRIDE;
     virtual void didCloseSocketStream(SocketStreamHandle*) OVERRIDE;
     virtual void didReceiveSocketStreamData(SocketStreamHandle*, const char*, int) OVERRIDE;
     virtual void didUpdateBufferedAmount(SocketStreamHandle*, size_t bufferedAmount) OVERRIDE;
     virtual void didFailSocketStream(SocketStreamHandle*, const SocketStreamError&) OVERRIDE;
 
     // FileReaderLoaderClient functions.
     virtual void didStartLoading();
     virtual void didReceiveData();
     virtual void didFinishLoading();
     virtual void didFail(int errorCode);
 
     using RefCounted<MainThreadWebSocketChannel>::ref;
     using RefCounted<MainThreadWebSocketChannel>::deref;
 
 protected:
     // WebSocketChannel functions.
     virtual void refWebSocketChannel() OVERRIDE { ref(); }
     virtual void derefWebSocketChannel() OVERRIDE { deref(); }
 
 private:
     MainThreadWebSocketChannel(Document*, WebSocketChannelClient*);
+    MainThreadWebSocketChannel(Document*, WebSocketChannelClient*, const ScriptCallFrame&);
 
     bool appendToBuffer(const char* data, size_t len);
     void skipBuffer(size_t len);
     bool processBuffer();
     void resumeTimerFired(Timer<MainThreadWebSocketChannel>*);
     void startClosingHandshake(int code, const String& reason);
     void closingTimerFired(Timer<MainThreadWebSocketChannel>*);
+    void failInternal();
 
     bool processFrame();
 
     // It is allowed to send a Blob as a binary frame if hybi-10 protocol is in use. Sending a Blob
     // can be delayed because it must be read asynchronously. Other types of data (String or
     // ArrayBuffer) may also be blocked by preceding sending request of a Blob.
     //
     // To address this situation, messages to be sent need to be stored in a queue. Whenever a new
     // data frame is going to be sent, it first must go to the queue. Items in the queue are processed
     // in the order they were put into the queue. Sending request of a Blob blocks further processing
@@ skipping 74 matching lines @@
     OwnPtr<FileReaderLoader> m_blobLoader;
     BlobLoaderStatus m_blobLoaderStatus;
 
     ScriptCallFrame m_callFrameAtConnection;
     WebSocketDeflateFramer m_deflateFramer;
 };
 
 } // namespace WebCore
 
 #endif // MainThreadWebSocketChannel_h