Fail WebSocket channel when handshake fails.

net/websockets/websocket_channel.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_
 #define NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 135 matching lines @@
       const std::vector<std::string>& requested_protocols,
       const GURL& origin,
       const WebSocketStreamCreator& creator);
 
   // Success callback from WebSocketStream::CreateAndConnectStream(). Reports
   // success to the event interface. May delete |this|.
   void OnConnectSuccess(scoped_ptr<WebSocketStream> stream);
 
   // Failure callback from WebSocketStream::CreateAndConnectStream(). Reports
   // failure to the event interface. May delete |this|.
-  void OnConnectFailure(uint16 websocket_error);
+  void OnConnectFailure(const std::string& message);
 
   // Returns true if state_ is SEND_CLOSED, CLOSE_WAIT or CLOSED.
   bool InClosingState() const;
 
   // Calls WebSocketStream::WriteFrames() with the appropriate arguments
   ChannelState WriteFrames() WARN_UNUSED_RESULT;
 
   // Callback from WebSocketStream::WriteFrames. Sends pending data or adjusts
   // the send quota of the renderer channel as appropriate. |result| is a net
   // error code, usually OK. If |synchronous| is true, then OnWriteDone() is
@@ skipping 25 matching lines @@
   // Low-level method to send a single frame. Used for both data and control
   // frames. Either sends the frame immediately or buffers it to be scheduled
   // when the current write finishes. |fin| and |op_code| are defined as for
   // SendFrame() above, except that |op_code| may also be a control frame
   // opcode.
   ChannelState SendIOBuffer(bool fin,
                             WebSocketFrameHeader::OpCode op_code,
                             const scoped_refptr<IOBuffer>& buffer,
                             size_t size) WARN_UNUSED_RESULT;
 
+  // TODO(yhirano): This is not the "Fail" operation but the (unclean) "Close"
+  // operation. Needs renaming & refactoring.

[Adam Rice, 2013/12/06 07:02:31]

It is certainly intended to implement the "Fail the WebSocket Connection"
operation as defined in RFC6455. In practice it is only used for protocol errors
after the handshake has completed.

The interface does need revising to allow for logging console messages.

[yhirano, 2013/12/06 08:54:56]

My understanding is that "_Fail the WebSocket Connection_" and just closing the
connection should be distinguished, is that right?
For example, WebSocketChannel::ProcessFrame calls FailChannel if the incoming
frame is masked, but the spec says that "a client MUST close a connection".
Currently FailChannels does NOT for "_Fail the WebSocket Connection_" but for
close. In other word, WebSocketChannel::ProcessFrame is correct -- just the
method name is wrong.
Thus I think renaming is needed.

[Adam Rice, 2013/12/09 01:21:41]

The spec goes on to say "In this case, it MAY use the status code 1002",
implying that it sends a Close frame before closing the TCP/IP connection. In
which case the behaviour is identical to _Fail the WebSocket Connection_ and it
is just a mistake in the RFC that it doesn't use that wording.

The WHATWG WebSocket API appears to require us to _Close the WebSocket
Connection_ without performing _Fail the WebSocket connection_ if the output
buffer is full (
http://www.whatwg.org/specs/web-apps/current-work/multipage/network.html#dom-...
). This wording appears to be new (replacing the old circular definition of
"with prejudice") but creates an unhelpful special case.

[yhirano, 2013/12/09 06:11:14]

Discussed offline.
I deleted the comment.
http://crbug.com/326899 will fix FailChannel.

   // Performs the "Fail the WebSocket Connection" operation as defined in
   // RFC6455. The supplied code and reason are sent back to the renderer in an
   // OnDropChannel message. If state_ is CONNECTED then a Close message is sent
   // to the remote host. If |expose| is SEND_REAL_ERROR then the remote host is
   // given the same status code passed to the renderer; otherwise it is sent a
   // fixed "Going Away" code.  Closes the stream_ and sets state_ to CLOSED.
   // FailChannel() always returns CHANNEL_DELETED. It is not valid to access any
   // member variables or methods after calling FailChannel().
   ChannelState FailChannel(ExposeError expose,
                            uint16 code,
@@ skipping 74 matching lines @@
   // The current state of the channel. Mainly used for sanity checking, but also
   // used to track the close state.
   State state_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketChannel);
 };
 
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_