Websocket should fire 'error' event if no server available

webkit/tools/test_shell/simple_socket_stream_bridge.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "webkit/tools/test_shell/simple_socket_stream_bridge.h"
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
+#include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "net/socket_stream/socket_stream_job.h"
 #include "net/websockets/websocket_job.h"
 #include "net/url_request/url_request_context.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSocketStreamHandle.h"
 #include "webkit/glue/websocketstreamhandle_bridge.h"
 #include "webkit/glue/websocketstreamhandle_delegate.h"
 
 using webkit_glue::WebSocketStreamHandleBridge;
 
@@ skipping 18 matching lines @@
   virtual void Close() OVERRIDE;
 
   // net::SocketStream::Delegate methods.
   virtual void OnConnected(net::SocketStream* req,
                            int max_pending_send_allowed) OVERRIDE;
   virtual void OnSentData(net::SocketStream* req,
                           int amount_sent) OVERRIDE;
   virtual void OnReceivedData(net::SocketStream* req,
                               const char* data, int len) OVERRIDE;
   virtual void OnClose(net::SocketStream* req) OVERRIDE;
+  virtual void OnError(const net::SocketStream* req, int error_code) OVERRIDE;
 
  private:
   virtual ~WebSocketStreamHandleBridgeImpl();
 
   // Runs on |g_io_thread|;
   void DoConnect(const GURL& url);
   void DoSend(std::vector<char>* data);
   void DoClose();
 
   // Runs on |message_loop_|;
   void DoOnConnected(int max_amount_send_allowed);
   void DoOnSentData(int amount_sent);
   void DoOnReceivedData(std::vector<char>* data);
   void DoOnClose();
+  void DoOnError(int error_code, const char* error_msg);
 
   int socket_id_;
   MessageLoop* message_loop_;
   WebKit::WebSocketStreamHandle* handle_;
   webkit_glue::WebSocketStreamHandleDelegate* delegate_;
 
   scoped_refptr<net::SocketStreamJob> socket_;
   // Number of pending tasks to handle net::SocketStream::Delegate methods.
   base::subtle::Atomic32 num_pending_tasks_;
 
@@ skipping 72 matching lines @@
 void WebSocketStreamHandleBridgeImpl::OnClose(net::SocketStream* socket) {
   base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, 1);
   // Release socket_ on IO thread.
   socket_ = NULL;
   socket_id_ = kNoSocketId;
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebSocketStreamHandleBridgeImpl::DoOnClose, this));
 }
 
+void WebSocketStreamHandleBridgeImpl::OnError(
+    const net::SocketStream* socket, int error_code) {
+  base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, 1);
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&WebSocketStreamHandleBridgeImpl::DoOnError, this,
+                 error_code, net::ErrorToString(error_code)));
+}
+
 void WebSocketStreamHandleBridgeImpl::DoConnect(const GURL& url) {
   DCHECK(MessageLoop::current() == g_io_thread);
   socket_ = net::SocketStreamJob::CreateSocketStreamJob(
       url, this, g_request_context->transport_security_state(),
       g_request_context->ssl_config_service());
   socket_->set_context(g_request_context);
   socket_->Connect();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoSend(std::vector<char>* data) {
@@ skipping 43 matching lines @@
   DCHECK_EQ(num_pending_tasks_, 0);
   DCHECK(!socket_);
   DCHECK_EQ(socket_id_, kNoSocketId);
   webkit_glue::WebSocketStreamHandleDelegate* delegate = delegate_;
   delegate_ = NULL;
   if (delegate)
     delegate->DidClose(handle_);
   Release();
 }
 
+void WebSocketStreamHandleBridgeImpl::DoOnError(
+    int error_code, const char* error_msg) {
+  DCHECK(MessageLoop::current() == message_loop_);
+  base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, -1);
+  if (delegate_)
+    delegate_->DidFail(handle_, error_code, ASCIIToUTF16(error_msg));
+}
+
 }  // namespace
 
 /* static */
 void SimpleSocketStreamBridge::InitializeOnIOThread(
     net::URLRequestContext* request_context) {
   g_io_thread = MessageLoop::current();
   g_request_context = request_context;
 }
 
 void SimpleSocketStreamBridge::Cleanup() {
   g_io_thread = NULL;
   g_request_context = NULL;
 }
 
 /* static */
 webkit_glue::WebSocketStreamHandleBridge* SimpleSocketStreamBridge::Create(
     WebKit::WebSocketStreamHandle* handle,
     webkit_glue::WebSocketStreamHandleDelegate* delegate) {
   return new WebSocketStreamHandleBridgeImpl(handle, delegate);
 }