Create a path to deliver SocketStream errors to the renderer.

webkit/tools/test_shell/simple_socket_stream_bridge.cc

 // Copyright (c) 2011 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/message_loop.h"
 #include "base/ref_counted.h"
@@ skipping 28 matching lines @@
   virtual void Close();
 
   // net::SocketStream::Delegate methods.
   virtual void OnConnected(net::SocketStream* req,
                            int max_pending_send_allowed);
   virtual void OnSentData(net::SocketStream* req,
                           int amount_sent);
   virtual void OnReceivedData(net::SocketStream* req,
                               const char* data, int len);
   virtual void OnClose(net::SocketStream* req);
+  virtual void OnError(const net::SocketStream* req, int error);
 
  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);
 
   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.
   int num_pending_tasks_;
 
@@ skipping 74 matching lines @@
 void WebSocketStreamHandleBridgeImpl::OnClose(net::SocketStream* socket) {
   ++num_pending_tasks_;
   // Release socket_ on IO thread.
   socket_ = NULL;
   socket_id_ = kNoSocketId;
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoOnClose));
 }
 
+void WebSocketStreamHandleBridgeImpl::OnError(const net::SocketStream* socket,
+                                              int error) {
+  ++num_pending_tasks_;
+  message_loop_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoOnError,
+                        error));
+}
+
 void WebSocketStreamHandleBridgeImpl::DoConnect(const GURL& url) {
   DCHECK(MessageLoop::current() == g_io_thread);
   socket_ = net::SocketStreamJob::CreateSocketStreamJob(url, this);
   socket_->set_context(g_request_context);
   socket_->Connect();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoSend(std::vector<char>* data) {
   DCHECK(MessageLoop::current() == g_io_thread);
   scoped_ptr<std::vector<char> > scoped_data(data);
@@ skipping 41 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) {
+  DCHECK(MessageLoop::current() == message_loop_);
+  --num_pending_tasks_;
+  if (delegate_)
+    delegate_->DidFail(handle_, error);
+}
+
 }  // 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;
 }
 
 namespace webkit_glue {
 
 /* static */
 WebSocketStreamHandleBridge* WebSocketStreamHandleBridge::Create(
     WebKit::WebSocketStreamHandle* handle,
     WebSocketStreamHandleDelegate* delegate) {
   return new WebSocketStreamHandleBridgeImpl(handle, delegate);
 }
 
 }  // namespace webkit_glue