Notify WebSocket connection failure, chromium side

content/child/websocket_bridge.cc

 // 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.
 
 #include "content/child/websocket_bridge.h"
 
 #include <stdint.h>
 #include <string>
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "third_party/WebKit/public/platform/WebVector.h"
 
 using WebKit::WebSocketHandle;
 using WebKit::WebSocketHandleClient;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebVector;
 
 namespace content {
 
+namespace {
+
+const unsigned short kAbnormalShutdownOpCode = 1006;
+
+}  // namespace
+
 WebSocketBridge::WebSocketBridge()
     : channel_id_(kInvalidChannelId), client_(NULL) {}
 
 WebSocketBridge::~WebSocketBridge() {
+  if (channel_id_ != kInvalidChannelId) {
+    // The connection is abruptly disconnected by the renderer without
+    // closing handshake.
+    ChildThread::current()->Send(
+        new WebSocketMsg_DropChannel(channel_id_,
+                                     false,
+                                     kAbnormalShutdownOpCode,
+                                     std::string()));
+  }
   Disconnect();
 }
 
 bool WebSocketBridge::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebSocketBridge, msg)
     IPC_MESSAGE_HANDLER(WebSocketMsg_AddChannelResponse, DidConnect)
+    IPC_MESSAGE_HANDLER(WebSocketMsg_NotifyFailure, DidFail)
     IPC_MESSAGE_HANDLER(WebSocketMsg_SendFrame, DidReceiveData)
     IPC_MESSAGE_HANDLER(WebSocketMsg_FlowControl, DidReceiveFlowControl)
     IPC_MESSAGE_HANDLER(WebSocketMsg_DropChannel, DidClose)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WebSocketBridge::DidConnect(bool fail,
                                  const std::string& selected_protocol,
                                  const std::string& extensions) {
   WebSocketHandleClient* client = client_;
   DVLOG(1) << "WebSocketBridge::DidConnect("
            << fail << ", "
            << selected_protocol << ", "
            << extensions << ")";
   if (fail)
     Disconnect();
   if (!client)
     return;
 
   WebString protocol_to_pass = WebString::fromUTF8(selected_protocol);
   WebString extensions_to_pass = WebString::fromUTF8(extensions);
   client->didConnect(this, fail, protocol_to_pass, extensions_to_pass);
   // |this| can be deleted here.
 }
 
+void WebSocketBridge::DidFail(const std::string& message) {
+  DVLOG(1) << "WebSocketBridge::DidFail(" << message << ")";
+  if (!client_)
+    return;
+
+  WebString message_to_pass = WebString::fromUTF8(message);
+  client_->didFail(this, message_to_pass);
+  // |this| can be deleted here.
+}
+
 void WebSocketBridge::DidReceiveData(bool fin,
                                      WebSocketMessageType type,
                                      const std::vector<char>& data) {
   DVLOG(1) << "WebSocketBridge::DidReceiveData("
            << fin << ", "
            << type << ", "
            << "(data size = " << data.size() << "))";
   if (!client_)
     return;
 
@@ skipping 17 matching lines @@
 
 void WebSocketBridge::DidReceiveFlowControl(int64_t quota) {
   DVLOG(1) << "WebSocketBridge::DidReceiveFlowControl(" << quota << ")";
   if (!client_)
     return;
 
   client_->didReceiveFlowControl(this, quota);
   // |this| can be deleted here.
 }
 
-void WebSocketBridge::DidClose(unsigned short code,
+void WebSocketBridge::DidClose(bool was_clean,
+                               unsigned short code,
                                const std::string& reason) {
   DVLOG(1) << "WebSocketBridge::DidClose("
+           << was_clean << ", "
            << code << ", "
            << reason << ")";
   WebSocketHandleClient* client = client_;
   Disconnect();
   if (!client)
     return;
 
   WebString reason_to_pass = WebString::fromUTF8(reason);
-  client->didClose(this, code, reason_to_pass);
+  client->didClose(this, was_clean, code, reason_to_pass);
   // |this| can be deleted here.
 }
 
 void WebSocketBridge::connect(
     const WebURL& url,
     const WebVector<WebString>& protocols,
     const WebString& origin,
     WebSocketHandleClient* client) {
   DCHECK_EQ(kInvalidChannelId, channel_id_);
   WebSocketDispatcher* dispatcher =
@@ skipping 59 matching lines @@
 }
 
 void WebSocketBridge::close(unsigned short code,
                             const WebString& reason) {
   if (channel_id_ == kInvalidChannelId)
     return;
 
   std::string reason_to_pass = reason.utf8();
   DVLOG(1) << "Bridge #" << channel_id_ << " Close("
            << code << ", " << reason_to_pass << ")";
+  // This method is for closing handshake and hence |was_clean| shall be true.
   ChildThread::current()->Send(
-      new WebSocketMsg_DropChannel(channel_id_, code, reason_to_pass));
+      new WebSocketMsg_DropChannel(channel_id_, true, code, reason_to_pass));
 }
 
 void WebSocketBridge::Disconnect() {
   if (channel_id_ == kInvalidChannelId)
     return;
   WebSocketDispatcher* dispatcher =
       ChildThread::current()->websocket_dispatcher();
   dispatcher->RemoveBridge(channel_id_);
 
   channel_id_ = kInvalidChannelId;
   client_ = NULL;
 }
 
 }  // namespace content