Changes to HttpNetworkTransaction for WebSocket Handshake

net/http/http_network_transaction_unittest.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/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 46 matching lines @@
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/ssl/ssl_info.h"
 #include "net/test/cert_test_util.h"
+#include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 const base::string16 kBar(ASCIIToUTF16("bar"));
 const base::string16 kBar2(ASCIIToUTF16("bar2"));
@@ skipping 11873 matching lines @@
 };
 
 // Fake HttpStreamRequest that simply records calls to SetPriority()
 // and vends FakeStreams with its current priority.
 class FakeStreamRequest : public HttpStreamRequest,
                           public base::SupportsWeakPtr<FakeStreamRequest> {
  public:
   FakeStreamRequest(RequestPriority priority,
                     HttpStreamRequest::Delegate* delegate)
       : priority_(priority),
-        delegate_(delegate) {}
+        delegate_(delegate),
+        websocket_stream_factory_(NULL) {}
+  FakeStreamRequest(RequestPriority priority,
+                    HttpStreamRequest::Delegate* delegate,
+                    WebSocketHandshakeStreamBase::Factory* factory)
+      : priority_(priority),
+        delegate_(delegate),
+        websocket_stream_factory_(factory) {}
 
   virtual ~FakeStreamRequest() {}
 
   RequestPriority priority() const { return priority_; }
 
+  const WebSocketHandshakeStreamBase::Factory* websocket_stream_factory()
+      const {
+    return websocket_stream_factory_;
+  }
+
   // Create a new FakeStream and pass it to the request's
   // delegate. Returns a weak pointer to the FakeStream.
   base::WeakPtr<FakeStream> FinishStreamRequest() {
     FakeStream* fake_stream = new FakeStream(priority_);
     // Do this before calling OnStreamReady() as OnStreamReady() may
     // immediately delete |fake_stream|.
     base::WeakPtr<FakeStream> weak_stream = fake_stream->AsWeakPtr();
     delegate_->OnStreamReady(SSLConfig(), ProxyInfo(), fake_stream);
     return weak_stream;
   }
@@ skipping 21 matching lines @@
     return kProtoUnknown;
   }
 
   virtual bool using_spdy() const OVERRIDE {
     return false;
   }
 
  private:
   RequestPriority priority_;
   HttpStreamRequest::Delegate* const delegate_;
+  WebSocketHandshakeStreamBase::Factory* websocket_stream_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStreamRequest);
 };
 
 // Fake HttpStreamFactory that vends FakeStreamRequests.
 class FakeStreamFactory : public HttpStreamFactory {
  public:
   FakeStreamFactory() {}
   virtual ~FakeStreamFactory() {}
 
@@ skipping 16 matching lines @@
   }
 
   virtual HttpStreamRequest* RequestWebSocketHandshakeStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::Factory* factory,
       const BoundNetLog& net_log) OVERRIDE {
-    ADD_FAILURE();
-    return NULL;
+    FakeStreamRequest* fake_request =
+        new FakeStreamRequest(priority, delegate, factory);
+    last_stream_request_ = fake_request->AsWeakPtr();
+    return fake_request;
   }
 
   virtual void PreconnectStreams(int num_streams,
                                  const HttpRequestInfo& info,
                                  RequestPriority priority,
                                  const SSLConfig& server_ssl_config,
                                  const SSLConfig& proxy_ssl_config) OVERRIDE {
     ADD_FAILURE();
   }
 
   virtual base::Value* PipelineInfoToValue() const OVERRIDE {
     ADD_FAILURE();
     return NULL;
   }
 
   virtual const HostMappingRules* GetHostMappingRules() const OVERRIDE {
     ADD_FAILURE();
     return NULL;
   }
 
  private:
   base::WeakPtr<FakeStreamRequest> last_stream_request_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStreamFactory);
 };
 
+// TODO(yhirano): Split this class out into a net/websockets file, if it is
+// worth doing.
+class FakeWebSocketStreamFactory :
+      public WebSocketHandshakeStreamBase::Factory {
+ public:
+  virtual WebSocketHandshakeStreamBase* CreateBasicStream(
+      ClientSocketHandle* connection,
+      bool using_proxy) OVERRIDE {
+    NOTREACHED();
+    return NULL;
+  }
+
+  virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
+      const base::WeakPtr<SpdySession>& session,
+      bool use_relative_url) OVERRIDE {
+    NOTREACHED();
+    return NULL;
+  };
+
+  virtual ~FakeWebSocketStreamFactory() {}
+
+  virtual scoped_ptr<WebSocketStream> Upgrade() {
+    NOTREACHED();
+    return scoped_ptr<WebSocketStream>();
+  }
+};
+
 }  // namespace
 
 // Make sure that HttpNetworkTransaction passes on its priority to its
 // stream request on start.
 TEST_P(HttpNetworkTransactionTest, SetStreamRequestPriorityOnStart) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpNetworkSessionPeer peer(session);
   FakeStreamFactory* fake_factory = new FakeStreamFactory();
   peer.SetHttpStreamFactory(fake_factory);
 
@@ skipping 56 matching lines @@
       fake_factory->last_stream_request();
   ASSERT_TRUE(fake_request != NULL);
   base::WeakPtr<FakeStream> fake_stream = fake_request->FinishStreamRequest();
   ASSERT_TRUE(fake_stream != NULL);
   EXPECT_EQ(LOW, fake_stream->priority());
 
   trans.SetPriority(LOWEST);
   EXPECT_EQ(LOWEST, fake_stream->priority());
 }
 
+TEST_P(HttpNetworkTransactionTest, CreateWebSocketHandshakeStream) {
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+  HttpNetworkSessionPeer peer(session);
+  FakeStreamFactory* fake_factory = new FakeStreamFactory();
+  FakeWebSocketStreamFactory websocket_stream_factory;
+  peer.SetWebSocketHandshakeStreamFactory(fake_factory);
+
+  HttpNetworkTransaction trans(LOW, session);
+  trans.SetWebSocketHandshakeStreamFactory(&websocket_stream_factory);
+
+  HttpRequestInfo request;
+  TestCompletionCallback callback;
+  request.method = "GET";
+  request.url = GURL("ws://www.google.com/");
+
+  EXPECT_EQ(ERR_IO_PENDING,
+            trans.Start(&request, callback.callback(), BoundNetLog()));
+
+  base::WeakPtr<FakeStreamRequest> fake_request =
+      fake_factory->last_stream_request();
+  ASSERT_TRUE(fake_request != NULL);
+  EXPECT_EQ(&websocket_stream_factory,
+            fake_request->websocket_stream_factory());
+}
+
+TEST_P(HttpNetworkTransactionTest, CreateWebSocketSecureHandshakeStream) {
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+  HttpNetworkSessionPeer peer(session);
+  FakeStreamFactory* fake_factory = new FakeStreamFactory();
+  FakeWebSocketStreamFactory websocket_stream_factory;
+  peer.SetWebSocketHandshakeStreamFactory(fake_factory);
+
+  HttpNetworkTransaction trans(LOW, session);
+  trans.SetWebSocketHandshakeStreamFactory(&websocket_stream_factory);
+
+  HttpRequestInfo request;
+  TestCompletionCallback callback;
+  request.method = "GET";
+  request.url = GURL("wss://www.google.com/");
+
+  EXPECT_EQ(ERR_IO_PENDING,
+            trans.Start(&request, callback.callback(), BoundNetLog()));
+
+  base::WeakPtr<FakeStreamRequest> fake_request =
+      fake_factory->last_stream_request();
+  ASSERT_TRUE(fake_request != NULL);
+  EXPECT_EQ(&websocket_stream_factory,
+            fake_request->websocket_stream_factory());
+}
+
 // Tests that when a used socket is returned to the SSL socket pool, it's closed
 // if the transport socket pool is stalled on the global socket limit.
 TEST_P(HttpNetworkTransactionTest, CloseSSLSocketOnIdleForHttpRequest) {
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   ClientSocketPoolManager::set_max_sockets_per_pool(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 
   // Set up SSL request.
 
@@ skipping 145 matching lines @@
   // established, to let the HTTP request start.
   ASSERT_EQ(OK, http_callback.WaitForResult());
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(http_trans.get(), &response_data));
   EXPECT_EQ("falafel", response_data);
 
   EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session));
 }
 
 }  // namespace net