Changes to HttpNetworkTransaction for WebSocket Handshake

net/http/http_cache_unittest.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 "net/http/http_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 14 matching lines @@
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_delegate.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/http/http_util.h"
 #include "net/http/mock_http_cache.h"
 #include "net/ssl/ssl_cert_request_info.h"
+#include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
 
 // Tests the load timing values of a request that goes through a
 // MockNetworkTransaction.
 void TestLoadTimingNetworkRequest(const net::LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
@@ skipping 522 matching lines @@
 };
 
 struct Context {
   Context() : result(net::ERR_IO_PENDING) {}
 
   int result;
   net::TestCompletionCallback callback;
   scoped_ptr<net::HttpTransaction> trans;
 };
 
+class FakeWebSocketHandshakeStreamFactory
+    : public net::WebSocketHandshakeStreamBase::Factory {
+ public:
+  virtual ~FakeWebSocketHandshakeStreamFactory() {}
+  virtual net::WebSocketHandshakeStreamBase* CreateBasicStream(
+      net::ClientSocketHandle* connect, bool using_proxy) OVERRIDE {
+    return NULL;
+  }
+  virtual net::WebSocketHandshakeStreamBase* CreateSpdyStream(
+      const base::WeakPtr<net::SpdySession>& session,
+      bool use_relative_url) OVERRIDE {
+    return NULL;
+  }
+};
+
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
 // Tests.
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
   scoped_ptr<net::HttpTransaction> trans;
@@ skipping 5704 matching lines @@
   if (cache.network_layer()->last_transaction()) {
     EXPECT_EQ(net::LOW,
               cache.network_layer()->last_create_transaction_priority());
     EXPECT_EQ(net::HIGHEST,
               cache.network_layer()->last_transaction()->priority());
   }
 
   EXPECT_EQ(net::OK, callback.WaitForResult());
 }
 
+// Make sure that calling SetWebSocketHandshakeStreamFactory on a cache
+// transaction passes on its factory updates to its underlying network
+// transaction.
+TEST(HttpCache, SetWebSocketHandshakeStreamFactory) {
+  MockHttpCache cache;
+
+  FakeWebSocketHandshakeStreamFactory factory;
+  scoped_ptr<net::HttpTransaction> trans;
+  EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(
+      net::IDLE, &trans, NULL));
+  ASSERT_TRUE(trans.get());
+
+  EXPECT_FALSE(cache.network_layer()->last_transaction());
+
+  net::HttpRequestInfo info;
+  info.url = GURL(kSimpleGET_Transaction.url);
+  net::TestCompletionCallback callback;
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            trans->Start(&info, callback.callback(), net::BoundNetLog()));
+
+  ASSERT_TRUE(cache.network_layer()->last_transaction());
+  EXPECT_FALSE(cache.network_layer()->last_transaction()->
+               websocket_handshake_stream_factory());
+  trans->SetWebSocketHandshakeStreamFactory(&factory);
+  EXPECT_EQ(&factory,
+            cache.network_layer()->last_transaction()->
+            websocket_handshake_stream_factory());
+  EXPECT_EQ(net::OK, callback.WaitForResult());
+}
+
 // Make sure that a cache transaction passes on its priority to
 // newly-created network transactions.
 TEST(HttpCache, SetPriorityNewTransaction) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
                           "ETag: \"foo\"\n"
                           "Accept-Ranges: bytes\n"
@@ skipping 26 matching lines @@
   trans->SetPriority(net::HIGHEST);
   // Should trigger a new network transaction and pick up the new
   // priority.
   ReadAndVerifyTransaction(trans.get(), transaction);
 
   EXPECT_EQ(net::HIGHEST,
             cache.network_layer()->last_create_transaction_priority());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }