Mojo: Implement the rest of the WebSocket interface.

mojo/services/network/web_socket_impl.cc

 // Copyright 2014 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.
 
 #include "mojo/services/network/web_socket_impl.h"
 
 #include "base/logging.h"
 #include "mojo/services/network/network_context.h"
 #include "net/websockets/websocket_channel.h"
 #include "net/websockets/websocket_errors.h"
@@ skipping 80 matching lines @@
   WebSocketClientPtr client_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketEventHandler);
 };
 
 ChannelState WebSocketEventHandler::OnAddChannelResponse(
     bool fail,
     const std::string& selected_protocol,
     const std::string& extensions) {
   client_->DidConnect(fail, selected_protocol, extensions);
+  if (fail)
+    return WebSocketEventInterface::CHANNEL_DELETED;
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketEventHandler::OnDataFrame(
     bool fin,
     net::WebSocketFrameHeader::OpCode type,
     const std::vector<char>& data) {
   // TODO(mpcomplete): reuse the data pipe for subsequent frames.
   uint32_t num_bytes = static_cast<uint32_t>(data.size());
   MojoCreateDataPipeOptions options;
@@ skipping 14 matching lines @@
 ChannelState WebSocketEventHandler::OnClosingHandshake() {
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketEventHandler::OnFlowControl(int64 quota) {
   client_->DidReceiveFlowControl(quota);
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketEventHandler::OnDropChannel(bool was_clean,
-                                          uint16 code,
-                                          const std::string& reason) {
-  return WebSocketEventInterface::CHANNEL_ALIVE;
+                                                  uint16 code,
+                                                  const std::string& reason) {
+  client_->DidClose(was_clean, code, reason);
+  return WebSocketEventInterface::CHANNEL_DELETED;
 }
 
 ChannelState WebSocketEventHandler::OnFailChannel(const std::string& message) {
-  return WebSocketEventInterface::CHANNEL_ALIVE;
+  client_->DidFail(message);
+  return WebSocketEventInterface::CHANNEL_DELETED;
 }
 
 ChannelState WebSocketEventHandler::OnStartOpeningHandshake(
     scoped_ptr<net::WebSocketHandshakeRequestInfo> request) {
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketEventHandler::OnFinishOpeningHandshake(
     scoped_ptr<net::WebSocketHandshakeResponseInfo> response) {
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketEventHandler::OnSSLCertificateError(
     scoped_ptr<net::WebSocketEventInterface::SSLErrorCallbacks> callbacks,
     const GURL& url,
     const net::SSLInfo& ssl_info,
     bool fatal) {
-  // The above method is always asynchronous.
-  return WebSocketEventInterface::CHANNEL_ALIVE;
+  client_->DidFail("SSL Error");
+  return WebSocketEventInterface::CHANNEL_DELETED;
 }
 
 }  // namespace mojo
 
 WebSocketImpl::WebSocketImpl(NetworkContext* context) : context_(context) {
 }
 
 WebSocketImpl::~WebSocketImpl() {
 }
 
@@ skipping 21 matching lines @@
   ReadDataRaw(data_pipe.get(), &data[0], &num_bytes, MOJO_READ_DATA_FLAG_NONE);
   channel_->SendFrame(
       fin, ConvertTo<net::WebSocketFrameHeader::OpCode>(type), data);
 }
 
 void WebSocketImpl::FlowControl(int64_t quota) {
   DCHECK(channel_);
   channel_->SendFlowControl(quota);
 }
 
-void WebSocketImpl::Close(int16_t code, const String& reason) {
+void WebSocketImpl::Close(uint16_t code, const String& reason) {
   DCHECK(channel_);
   channel_->StartClosingHandshake(code, reason);
 }
 
-
 }  // namespace mojo