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_,
+                                     true,
+                                     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_SendFrame, DidReceiveData)
     IPC_MESSAGE_HANDLER(WebSocketMsg_FlowControl, DidReceiveFlowControl)
     IPC_MESSAGE_HANDLER(WebSocketMsg_DropChannel, DidClose)
@@ skipping 51 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 fail,
+                               unsigned short code,
                                const std::string& reason) {
   DVLOG(1) << "WebSocketBridge::DidClose("
+           << fail << ", "
            << 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, fail, 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 |fail| shall be false.
   ChildThread::current()->Send(
-      new WebSocketMsg_DropChannel(channel_id_, code, reason_to_pass));
+      new WebSocketMsg_DropChannel(channel_id_, false, 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