Notify WebSocket connection failure, chromium side

net/websockets/websocket_channel.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 "net/websockets/websocket_channel.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"  // for size_t
 #include "base/bind.h"
@@ skipping 274 matching lines @@
       return;
 
     // If a recoverable error condition existed, it would go here.
 
     default:
       DCHECK_LT(result, 0)
           << "WriteFrames() should only return OK or ERR_ codes";
       stream_->Close();
       if (state_ != CLOSED) {
         state_ = CLOSED;
-        event_interface_->OnDropChannel(kWebSocketErrorAbnormalClosure,
+        // TODO(yhirano): Set |fail| appropriately.

[Adam Rice, 2013/10/23 03:18:06]

The OnDropChannel-calling code changes a bit in
https://codereview.chromium.org/26544003/ so I think we should leave this as a
TODO until that has landed (and the other ones).

[yhirano, 2013/10/23 05:42:23]

OK, I will implement this in future CLs.

+        bool fail = false;
+        event_interface_->OnDropChannel(fail,
+                                        kWebSocketErrorAbnormalClosure,
                                         "Abnormal Closure");
       }
       return;
   }
 }
 
 void WebSocketChannel::ReadFrames() {
   int result = OK;
   do {
     // This use of base::Unretained is safe because this object owns the
@@ skipping 43 matching lines @@
           << "ReadFrames() should only return OK or ERR_ codes";
       stream_->Close();
       if (state_ != CLOSED) {
         state_ = CLOSED;
         uint16 code = kWebSocketErrorAbnormalClosure;
         std::string reason = "Abnormal Closure";
         if (closing_code_ != 0) {
           code = closing_code_;
           reason = closing_reason_;
         }
-        event_interface_->OnDropChannel(code, reason);
+        // TODO(yhirano): Set |fail| appropriately.
+        bool fail = false;
+        event_interface_->OnDropChannel(fail, code, reason);
       }
       return;
   }
 }
 
 void WebSocketChannel::ProcessFrame(scoped_ptr<WebSocketFrame> frame) {
   if (frame->header.masked) {
     // RFC6455 Section 5.1 "A client MUST close a connection if it detects a
     // masked frame."
     FailChannel(SEND_REAL_ERROR,
@@ skipping 177 matching lines @@
     }
     SendClose(send_code, send_reason);  // Sets state_ to SEND_CLOSED
   }
   // Careful study of RFC6455 section 7.1.7 and 7.1.1 indicates the browser
   // should close the connection itself without waiting for the closing
   // handshake.
   stream_->Close();
   state_ = CLOSED;
 
   if (old_state != CLOSED) {
-    event_interface_->OnDropChannel(code, reason);
+    // TODO(yhirano): Set |fail| appropriately.
+    bool fail = false;
+    event_interface_->OnDropChannel(fail, code, reason);
   }
 }
 
 void WebSocketChannel::SendClose(uint16 code, const std::string& reason) {
   DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
   // TODO(ricea): Ensure reason.length() <= 123
   scoped_refptr<IOBuffer> body;
   size_t size = 0;
   if (code == kWebSocketErrorNoStatusReceived) {
     // Special case: translate kWebSocketErrorNoStatusReceived into a Close
@@ skipping 44 matching lines @@
   }
   std::string text(data + kWebSocketCloseCodeLength, data + size);
   // TODO(ricea): Is this check strict enough? In particular, check the
   // "Security Considerations" from RFC3629.
   if (IsStringUTF8(text)) {
     reason->swap(text);
   }
 }
 
 }  // namespace net