WebSocket over SPDY: WebSocketJob handling SpdyWebSocketStream

net/socket_stream/socket_stream_unittest.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 "net/socket_stream/socket_stream.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 struct SocketStreamEvent {
   enum EventType {
     EVENT_START_OPEN_CONNECTION, EVENT_CONNECTED, EVENT_SENT_DATA,
-    EVENT_RECEIVED_DATA, EVENT_CLOSE, EVENT_AUTH_REQUIRED,
+    EVENT_RECEIVED_DATA, EVENT_CLOSE, EVENT_AUTH_REQUIRED, EVENT_ERROR,
   };
 
   SocketStreamEvent(EventType type,
                     net::SocketStream* socket_stream,
                     int num,
                     const std::string& str,
                     net::AuthChallengeInfo* auth_challenge_info,
-                    net::CompletionCallback* callback)
+                    net::CompletionCallback* callback,
+                    int error)
       : event_type(type), socket(socket_stream), number(num), data(str),
-        auth_info(auth_challenge_info) {}
+        auth_info(auth_challenge_info), error_code(error) {}
 
   EventType event_type;
   net::SocketStream* socket;
   int number;
   std::string data;
   scoped_refptr<net::AuthChallengeInfo> auth_info;
+  int error_code;
 };
 
 class SocketStreamEventRecorder : public net::SocketStream::Delegate {
  public:
   explicit SocketStreamEventRecorder(net::CompletionCallback* callback)
       : callback_(callback) {}
   virtual ~SocketStreamEventRecorder() {}
 
   void SetOnStartOpenConnection(
       const base::Callback<int(SocketStreamEvent*)>& callback) {
@@ skipping 11 matching lines @@
       const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_received_data_ = callback;
   }
   void SetOnClose(const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_close_ = callback;
   }
   void SetOnAuthRequired(
       const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_auth_required_ = callback;
   }
+  void SetOnError(const base::Callback<void(SocketStreamEvent*)>& callback) {
+    on_error_ = callback;
+  }
 
   virtual int OnStartOpenConnection(net::SocketStream* socket,
                                     net::CompletionCallback* callback) {
     connection_callback_ = callback;
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
-                          socket, 0, std::string(), NULL, callback));
+                          socket, 0, std::string(), NULL, callback, net::OK));
     if (!on_start_open_connection_.is_null())
       return on_start_open_connection_.Run(&events_.back());
     return net::OK;
   }
   virtual void OnConnected(net::SocketStream* socket,
                            int num_pending_send_allowed) {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_CONNECTED,
                           socket, num_pending_send_allowed, std::string(),
-                          NULL, NULL));
+                          NULL, NULL, net::OK));
     if (!on_connected_.is_null())
       on_connected_.Run(&events_.back());
   }
   virtual void OnSentData(net::SocketStream* socket,
                           int amount_sent) {
     events_.push_back(
-        SocketStreamEvent(SocketStreamEvent::EVENT_SENT_DATA,
-                          socket, amount_sent, std::string(), NULL, NULL));
+        SocketStreamEvent(SocketStreamEvent::EVENT_SENT_DATA, socket,
+                          amount_sent, std::string(), NULL, NULL, net::OK));
     if (!on_sent_data_.is_null())
       on_sent_data_.Run(&events_.back());
   }
   virtual void OnReceivedData(net::SocketStream* socket,
                               const char* data, int len) {
     events_.push_back(
-        SocketStreamEvent(SocketStreamEvent::EVENT_RECEIVED_DATA,
-                          socket, len, std::string(data, len), NULL, NULL));
+        SocketStreamEvent(SocketStreamEvent::EVENT_RECEIVED_DATA, socket, len,
+                          std::string(data, len), NULL, NULL, net::OK));
     if (!on_received_data_.is_null())
       on_received_data_.Run(&events_.back());
   }
   virtual void OnClose(net::SocketStream* socket) {
     events_.push_back(
-        SocketStreamEvent(SocketStreamEvent::EVENT_CLOSE,
-                          socket, 0, std::string(), NULL, NULL));
+        SocketStreamEvent(SocketStreamEvent::EVENT_CLOSE, socket, 0,
+                          std::string(), NULL, NULL, net::OK));
     if (!on_close_.is_null())
       on_close_.Run(&events_.back());
     if (callback_)
       callback_->Run(net::OK);
   }
   virtual void OnAuthRequired(net::SocketStream* socket,
                               net::AuthChallengeInfo* auth_info) {
     events_.push_back(
-        SocketStreamEvent(SocketStreamEvent::EVENT_AUTH_REQUIRED,
-                          socket, 0, std::string(), auth_info, NULL));
+        SocketStreamEvent(SocketStreamEvent::EVENT_AUTH_REQUIRED, socket, 0,
+                          std::string(), auth_info, NULL, net::OK));
     if (!on_auth_required_.is_null())
       on_auth_required_.Run(&events_.back());
   }
+  virtual void OnError(const net::SocketStream* socket, int error) {
+    events_.push_back(
+        SocketStreamEvent(SocketStreamEvent::EVENT_ERROR, NULL, 0,
+                          std::string(), NULL, NULL, error));
+    if (!on_error_.is_null())
+      on_error_.Run(&events_.back());
+    if (callback_)
+      callback_->Run(error);
+  }
 
   void DoClose(SocketStreamEvent* event) {
     event->socket->Close();
   }
   void DoRestartWithAuth(SocketStreamEvent* event) {
     VLOG(1) << "RestartWithAuth username=" << username_
             << " password=" << password_;
     event->socket->RestartWithAuth(username_, password_);
   }
   void SetAuthInfo(const string16& username,
@@ skipping 10 matching lines @@
   }
 
  private:
   std::vector<SocketStreamEvent> events_;
   base::Callback<int(SocketStreamEvent*)> on_start_open_connection_;
   base::Callback<void(SocketStreamEvent*)> on_connected_;
   base::Callback<void(SocketStreamEvent*)> on_sent_data_;
   base::Callback<void(SocketStreamEvent*)> on_received_data_;
   base::Callback<void(SocketStreamEvent*)> on_close_;
   base::Callback<void(SocketStreamEvent*)> on_auth_required_;
+  base::Callback<void(SocketStreamEvent*)> on_error_;
   net::CompletionCallback* callback_;
   net::CompletionCallback* connection_callback_;
 
   string16 username_;
   string16 password_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketStreamEventRecorder);
 };
 
 namespace net {
@@ skipping 129 matching lines @@
       GetMockClientSocketFactory();
   mock_socket_factory->AddSocketDataProvider(data_provider.get());
 
   socket_stream->SetClientSocketFactory(mock_socket_factory);
 
   socket_stream->Connect();
 
   callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
-  ASSERT_EQ(7U, events.size());
+  ASSERT_EQ(8U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[2].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[3].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[4].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[5].event_type);
-  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[6].event_type);
+  EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[6].event_type);
+  EXPECT_EQ(net::ERR_CONNECTION_CLOSED, events[6].error_code);
+  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[7].event_type);
 }
 
 TEST_F(SocketStreamTest, BasicAuthProxy) {
   MockClientSocketFactory mock_socket_factory;
   MockWrite data_writes1[] = {
     MockWrite("CONNECT example.com:80 HTTP/1.1\r\n"
               "Host: example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead data_reads1[] = {
@@ skipping 41 matching lines @@
   socket_stream->set_context(new TestURLRequestContext("myproxy:70"));
   MockHostResolver host_resolver;
   socket_stream->SetHostResolver(&host_resolver);
   socket_stream->SetClientSocketFactory(&mock_socket_factory);
 
   socket_stream->Connect();
 
   callback.WaitForResult();
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
-  ASSERT_EQ(4U, events.size());
+  ASSERT_EQ(5U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_AUTH_REQUIRED, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[2].event_type);
-  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
+  EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[3].event_type);
+  EXPECT_EQ(net::ERR_ABORTED, events[3].error_code);
+  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[4].event_type);
 
   // TODO(eroman): Add back NetLogTest here...
 }
 
 TEST_F(SocketStreamTest, IOPending) {
   TestCompletionCallback callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(&callback));
   delegate->SetOnConnected(base::Bind(
@@ skipping 38 matching lines @@
 
   socket_stream->Connect();
   io_callback_.WaitForResult();
   EXPECT_EQ(net::SocketStream::STATE_RESOLVE_PROTOCOL_COMPLETE,
             socket_stream->next_state_);
   delegate->CompleteConnection(net::OK);
 
   EXPECT_EQ(net::OK, callback.WaitForResult());
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
-  ASSERT_EQ(7U, events.size());
+  ASSERT_EQ(8U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[2].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[3].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[4].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[5].event_type);
-  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[6].event_type);
+  EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[6].event_type);
+  EXPECT_EQ(net::ERR_CONNECTION_CLOSED, events[6].error_code);
+  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[7].event_type);
 }
 
 TEST_F(SocketStreamTest, SwitchToSpdy) {
   TestCompletionCallback callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(&callback));
   delegate->SetOnStartOpenConnection(base::Bind(
       &SocketStreamTest::DoSwitchToSpdyTest, base::Unretained(this)));
 
   MockHostResolver host_resolver;
 
   scoped_refptr<SocketStream> socket_stream(
       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
 
   socket_stream->set_context(new TestURLRequestContext());
   socket_stream->SetHostResolver(&host_resolver);
 
   socket_stream->Connect();
 
-  EXPECT_EQ(net::OK, callback.WaitForResult());
+  EXPECT_EQ(net::ERR_PROTOCOL_SWITCHED, callback.WaitForResult());
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(2U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
-  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[1].event_type);
+  EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[1].event_type);
+  EXPECT_EQ(net::ERR_PROTOCOL_SWITCHED, events[1].error_code);
 }
 
 TEST_F(SocketStreamTest, SwitchAfterPending) {
   TestCompletionCallback callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(&callback));
   delegate->SetOnStartOpenConnection(base::Bind(
       &SocketStreamTest::DoIOPending, base::Unretained(this)));
 
   MockHostResolver host_resolver;
 
   scoped_refptr<SocketStream> socket_stream(
       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
 
   socket_stream->set_context(new TestURLRequestContext());
   socket_stream->SetHostResolver(&host_resolver);
 
   socket_stream->Connect();
   io_callback_.WaitForResult();
   EXPECT_EQ(net::SocketStream::STATE_RESOLVE_PROTOCOL_COMPLETE,
             socket_stream->next_state_);
   delegate->CompleteConnection(net::ERR_PROTOCOL_SWITCHED);
 
-  int result = callback.WaitForResult();
+  EXPECT_EQ(net::ERR_PROTOCOL_SWITCHED, callback.WaitForResult());
 
   const std::vector<SocketStreamEvent>& events = delegate->GetSeenEvents();
   ASSERT_EQ(2U, events.size());
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
-  EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[1].event_type);
-  EXPECT_EQ(net::OK, result);
+  EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[1].event_type);
+  EXPECT_EQ(net::ERR_PROTOCOL_SWITCHED, events[1].error_code);
 }
 
 }  // namespace net