Create a path to deliver SocketStream errors to the renderer.

net/socket_stream/socket_stream_unittest.cc

Index: net/socket_stream/socket_stream_unittest.cc
diff --git a/net/socket_stream/socket_stream_unittest.cc b/net/socket_stream/socket_stream_unittest.cc
index 24a0ff09451ace9f330b6f482850ebe92ce05eff..c15bc5a50de32c14bcdb4ff95f58760431a13b9a 100644
--- a/net/socket_stream/socket_stream_unittest.cc
+++ b/net/socket_stream/socket_stream_unittest.cc
@@ -9,6 +9,7 @@
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
 #include "net/base/mock_host_resolver.h"
+#include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/test_completion_callback.h"
@@ -21,7 +22,7 @@
 struct SocketStreamEvent {
   enum EventType {
     EVENT_CONNECTED, EVENT_SENT_DATA, EVENT_RECEIVED_DATA, EVENT_CLOSE,
-    EVENT_AUTH_REQUIRED,
+    EVENT_AUTH_REQUIRED, EVENT_ERROR,
   };
 
   SocketStreamEvent(EventType type, net::SocketStream* socket_stream,
@@ -45,6 +46,7 @@ class SocketStreamEventRecorder : public net::SocketStream::Delegate {
         on_received_data_(NULL),
         on_close_(NULL),
         on_auth_required_(NULL),
+        on_error_(NULL),
         callback_(callback) {}
   virtual ~SocketStreamEventRecorder() {
     delete on_connected_;
@@ -52,6 +54,7 @@ class SocketStreamEventRecorder : public net::SocketStream::Delegate {
     delete on_received_data_;
     delete on_close_;
     delete on_auth_required_;
+    delete on_error_;
   }
 
   void SetOnConnected(Callback1<SocketStreamEvent*>::Type* callback) {
@@ -69,6 +72,9 @@ class SocketStreamEventRecorder : public net::SocketStream::Delegate {
   void SetOnAuthRequired(Callback1<SocketStreamEvent*>::Type* callback) {
     on_auth_required_ = callback;
   }
+  void SetOnError(Callback1<SocketStreamEvent*>::Type* callback) {
+    on_error_ = callback;
+  }
 
   virtual void OnConnected(net::SocketStream* socket,
                            int num_pending_send_allowed) {
@@ -112,6 +118,16 @@ class SocketStreamEventRecorder : public net::SocketStream::Delegate {
     if (on_auth_required_)
       on_auth_required_->Run(&events_.back());
   }
+  virtual void OnError(const net::SocketStream* const_socket, int error) {
+    // TODO(yutak): Need to figure out a way to create SocketStreamEvent

[ukai, 2011/05/10 08:10:39]

can't we const net::SocketStream* socket in SocketStreamEvent?

[Yuta Kitamura, 2011/05/10 09:01:22]

No, because there are several uses of non-const member functions such as
|event->socket->SendData()| or |event->socket->Close()|.

[ukai, 2011/05/10 10:00:29]

Hmm. then I think SocketStreamEvent should have net::SocketStream* and const
net::SocketStream*.

or it might be ok to change OnError passes non-const net::SocketStream*.

+    // with |const net::SocketStream*|.
+    net::SocketStream* socket = const_cast<net::SocketStream*>(const_socket);
+    events_.push_back(
+        SocketStreamEvent(SocketStreamEvent::EVENT_ERROR,
+                          socket, error, std::string(), NULL));
+    if (on_error_)
+      on_error_->Run(&events_.back());
+  }
 
   void DoClose(SocketStreamEvent* event) {
     event->socket->Close();
@@ -138,6 +154,7 @@ class SocketStreamEventRecorder : public net::SocketStream::Delegate {
   Callback1<SocketStreamEvent*>::Type* on_received_data_;
   Callback1<SocketStreamEvent*>::Type* on_close_;
   Callback1<SocketStreamEvent*>::Type* on_auth_required_;
+  Callback1<SocketStreamEvent*>::Type* on_error_;
   net::CompletionCallback* callback_;
 
   string16 username_;
@@ -275,14 +292,16 @@ TEST_F(SocketStreamTest, CloseFlushPendingWrite) {
   callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
-  EXPECT_EQ(6U, events.size());
+  EXPECT_EQ(7U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[2].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[3].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[4].event_type);
-  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[5].event_type);
+  EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[5].event_type);
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, events[5].number);
+  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[6].event_type);
 }
 
 TEST_F(SocketStreamTest, BasicAuthProxy) {
@@ -344,11 +363,13 @@ TEST_F(SocketStreamTest, BasicAuthProxy) {
   callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
-  EXPECT_EQ(3U, events.size());
+  EXPECT_EQ(4U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_AUTH_REQUIRED, events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
-  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[2].event_type);
+  EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[2].event_type);
+  EXPECT_EQ(ERR_ABORTED, events[2].number);
+  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
 
   // TODO(eroman): Add back NetLogTest here...
 }