Reland rest of r77399.

net/spdy/spdy_network_transaction_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/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "net/base/auth.h"
 #include "net/base/net_log_unittest.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_transaction_unittest.h"
+#include "net/socket/client_socket_pool_base.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/platform_test.h"
 
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 // This is the expected list of advertised protocols from the browser's NPN
 // list.
 static const char kExpectedNPNString[] = "\x08http/1.1\x06spdy/2";
 
 enum SpdyNetworkTransactionTestTypes {
   SPDYNPN,
   SPDYNOSSL,
   SPDYSSL,
 };
 class SpdyNetworkTransactionTest
     : public ::testing::TestWithParam<SpdyNetworkTransactionTestTypes> {
  protected:
+
   virtual void SetUp() {
     // By default, all tests turn off compression.
     EnableCompression(false);
     google_get_request_initialized_ = false;
     google_post_request_initialized_ = false;
     google_chunked_post_request_initialized_ = false;
+
+    backup_jobs_prev_value_ =
+        internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled();
+    internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
+        false);
   }
 
   virtual void TearDown() {
     // Empty the current queue.
     MessageLoop::current()->RunAllPending();
+    internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
+        backup_jobs_prev_value_);
   }
 
   struct TransactionHelperResult {
     int rv;
     std::string status_line;
     std::string response_data;
     HttpResponseInfo response_info;
   };
 
   void EnableCompression(bool enabled) {
@@ skipping 101 matching lines @@
       }
 
       // Verify responses.
       const HttpResponseInfo* response = trans_->GetResponseInfo();
       ASSERT_TRUE(response != NULL);
       ASSERT_TRUE(response->headers != NULL);
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ(spdy_enabled_, response->was_fetched_via_spdy);
       if (test_type_ == SPDYNPN && spdy_enabled_) {
         EXPECT_TRUE(response->was_npn_negotiated);
-        EXPECT_TRUE(response->was_alternate_protocol_available);
       } else {
         EXPECT_TRUE(!response->was_npn_negotiated);
-        EXPECT_TRUE(!response->was_alternate_protocol_available);
       }
       // If SPDY is not enabled, a HTTP request should not be diverted
       // over a SSL session.
       if (!spdy_enabled_) {
         EXPECT_EQ(request_.url.SchemeIs("https"),
                   response->was_npn_negotiated);
       }
       EXPECT_EQ("192.0.2.33", response->socket_address.host());
       EXPECT_EQ(0, response->socket_address.port());
       output_.status_line = response->headers->GetStatusLine();
@@ skipping 46 matching lines @@
       DCHECK(!deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(true, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
         ssl_->next_proto = "spdy/2";
         ssl_->was_npn_negotiated = true;
       }
       ssl_vector_.push_back(ssl_);
-      if(test_type_ == SPDYNPN || test_type_ == SPDYSSL)
+      if (test_type_ == SPDYNPN || test_type_ == SPDYSSL)
         session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_.get());
       session_deps_->socket_factory->AddSocketDataProvider(data);
+      if (test_type_ == SPDYNPN) {
+        MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+        linked_ptr<StaticSocketDataProvider>
+            hanging_non_alternate_protocol_socket(
+                new StaticSocketDataProvider(NULL, 0, NULL, 0));
+        hanging_non_alternate_protocol_socket->set_connect_data(
+            never_finishing_connect);
+        session_deps_->socket_factory->AddSocketDataProvider(
+            hanging_non_alternate_protocol_socket.get());
+        alternate_vector_.push_back(hanging_non_alternate_protocol_socket);
+      }
     }
 
     void AddDeterministicData(DeterministicSocketData* data) {
       DCHECK(deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(true, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
         ssl_->next_proto = "spdy/2";
         ssl_->was_npn_negotiated = true;
       }
       ssl_vector_.push_back(ssl_);
-      if(test_type_ == SPDYNPN || test_type_ == SPDYSSL)
+      if (test_type_ == SPDYNPN || test_type_ == SPDYSSL) {
         session_deps_->deterministic_socket_factory->
             AddSSLSocketDataProvider(ssl_.get());
+      }
       session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);
+      if (test_type_ == SPDYNPN) {
+        MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+        scoped_refptr<DeterministicSocketData>
+            hanging_non_alternate_protocol_socket(
+            new DeterministicSocketData(NULL, 0, NULL, 0));
+        hanging_non_alternate_protocol_socket->set_connect_data(
+            never_finishing_connect);
+        session_deps_->deterministic_socket_factory->AddSocketDataProvider(
+            hanging_non_alternate_protocol_socket);
+        alternate_deterministic_vector_.push_back(
+            hanging_non_alternate_protocol_socket);
+      }
     }
 
     // This can only be called after RunPreTestSetup. It adds a Data Provider,
     // but not a corresponding SSL data provider
     void AddDataNoSSL(StaticSocketDataProvider* data) {
       DCHECK(!deterministic_);
       session_deps_->socket_factory->AddSocketDataProvider(data);
     }
     void AddDataNoSSL(DeterministicSocketData* data) {
       DCHECK(deterministic_);
@@ skipping 12 matching lines @@
     }
     scoped_ptr<SpdySessionDependencies>& session_deps() {
       return session_deps_;
     }
     int port() const { return port_; }
     SpdyNetworkTransactionTestTypes test_type() const { return test_type_; }
 
    private:
     typedef std::vector<StaticSocketDataProvider*> DataVector;
     typedef std::vector<linked_ptr<SSLSocketDataProvider> > SSLVector;
+    typedef std::vector<linked_ptr<StaticSocketDataProvider> > AlternateVector;
+    typedef std::vector<scoped_refptr<DeterministicSocketData> >
+        AlternateDeterministicVector;
     HttpRequestInfo request_;
     scoped_ptr<SpdySessionDependencies> session_deps_;
     scoped_refptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
     scoped_ptr<StaticSocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback;
     scoped_ptr<HttpNetworkTransaction> trans_;
     scoped_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
+    AlternateVector alternate_vector_;
+    AlternateDeterministicVector alternate_deterministic_vector_;
     const BoundNetLog& log_;
     SpdyNetworkTransactionTestTypes test_type_;
     int port_;
     bool deterministic_;
     bool spdy_enabled_;
   };
 
   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
                                              int expected_status);
 
@@ skipping 156 matching lines @@
   }
 
  private:
   bool google_get_request_initialized_;
   bool google_post_request_initialized_;
   bool google_chunked_post_request_initialized_;
   HttpRequestInfo google_get_request_;
   HttpRequestInfo google_post_request_;
   HttpRequestInfo google_chunked_post_request_;
   HttpRequestInfo google_get_push_request_;
+
+  bool backup_jobs_prev_value_;
 };
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different connection types: SPDY after NPN
 // negotiation, SPDY without SSL, and SPDY with SSL.
 INSTANTIATE_TEST_CASE_P(Spdy,
                         SpdyNetworkTransactionTest,
                         ::testing::Values(SPDYNOSSL, SPDYSSL, SPDYNPN));
 
 
@@ skipping 209 matching lines @@
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
     MockRead(true, 0, 0),  // EOF
   };
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
-  MockConnect never_finishing_connect(true, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(false, ERR_IO_PENDING);
 
   scoped_refptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
   data_placeholder->set_connect_data(never_finishing_connect);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
@@ skipping 168 matching lines @@
   scoped_ptr<spdy::SpdyFrame> fbody3(ConstructSpdyBodyFrame(5, true));
 
   spdy::SpdySettings settings;
   spdy::SettingsFlagsAndId id(0);
   id.set_id(spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
   const size_t max_concurrent_streams = 1;
 
   settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
   scoped_ptr<spdy::SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
-  MockWrite writes[] = { CreateMockWrite(*req),
-                         CreateMockWrite(*req2),
-                         CreateMockWrite(*req3),
+  MockWrite writes[] = {
+    CreateMockWrite(*req),
+    CreateMockWrite(*req2),
+    CreateMockWrite(*req3),
   };
+
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
     CreateMockRead(*resp),
     CreateMockRead(*body),
     CreateMockRead(*fbody),
     CreateMockRead(*resp2, 7),
     CreateMockRead(*body2),
     CreateMockRead(*fbody2),
     CreateMockRead(*resp3, 12),
     CreateMockRead(*body3),
     CreateMockRead(*fbody3),
 
     MockRead(true, 0, 0),  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   scoped_refptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
   {
-  NormalSpdyTransactionHelper helper(CreateGetRequest(),
-                                     BoundNetLog(), GetParam());
-  helper.RunPreTestSetup();
-  helper.AddData(data.get());
-  // We require placeholder data because three get requests are sent out, so
-  // there needs to be three sets of SSL connection data.
-  helper.AddData(data_placeholder.get());
-  helper.AddData(data_placeholder.get());
+    NormalSpdyTransactionHelper helper(CreateGetRequest(),
+                                       BoundNetLog(), GetParam());
+    helper.RunPreTestSetup();
+    helper.AddData(data.get());
+    // We require placeholder data because three get requests are sent out, so
+    // there needs to be three sets of SSL connection data.
+    helper.AddData(data_placeholder.get());
+    helper.AddData(data_placeholder.get());
     scoped_ptr<HttpNetworkTransaction> trans1(
         new HttpNetworkTransaction(helper.session()));
     scoped_ptr<HttpNetworkTransaction> trans2(
         new HttpNetworkTransaction(helper.session()));
     scoped_ptr<HttpNetworkTransaction> trans3(
         new HttpNetworkTransaction(helper.session()));
 
     TestCompletionCallback callback1;
     TestCompletionCallback callback2;
     TestCompletionCallback callback3;
@@ skipping 767 matching lines @@
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp.get(), 1, true),
     MockRead(true, 0, 0, 4)  // EOF
   };
 
   scoped_refptr<DeterministicSocketData> data(
       new DeterministicSocketData(reads, arraysize(reads),
-                            writes, arraysize(writes)));
+                                  writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.SetDeterministic();
   helper.RunPreTestSetup();
   helper.AddDeterministicData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 2070 matching lines @@
   MessageLoop::current()->RunAllPending();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("goodbye world", out.response_data);
 }
 
-TEST_P(SpdyNetworkTransactionTest, ConnectFailureFallbackToHttp) {
-  MockConnect connects[]  = {
-    MockConnect(true, ERR_NAME_NOT_RESOLVED),
-    MockConnect(false, ERR_NAME_NOT_RESOLVED),
-    MockConnect(true, ERR_INTERNET_DISCONNECTED),
-    MockConnect(false, ERR_INTERNET_DISCONNECTED)
-  };
-
-  for (size_t index = 0; index < arraysize(connects); ++index) {
-    scoped_ptr<spdy::SpdyFrame> req(
-        ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
-    MockWrite writes[] = {
-      CreateMockWrite(*req),
-      MockWrite(true, 0, 0)  // EOF
-    };
-
-    scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-    scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
-    MockRead reads[] = {
-      CreateMockRead(*resp),
-      CreateMockRead(*body),
-      MockRead(true, 0, 0)  // EOF
-    };
-
-    scoped_refptr<DelayedSocketData> data(
-        new DelayedSocketData(connects[index], 1, reads, arraysize(reads),
-                              writes, arraysize(writes)));
-    NormalSpdyTransactionHelper helper(CreateGetRequest(),
-                                       BoundNetLog(), GetParam());
-    helper.RunPreTestSetup();
-    helper.AddData(data.get());
-
-    // Set up http fallback data.
-    MockRead http_fallback_data[] = {
-      MockRead("HTTP/1.1 200 OK\r\n\r\n"),
-      MockRead("hello world!!!"),
-      MockRead(true, OK),
-    };
-
-    scoped_ptr<StaticSocketDataProvider> http_fallback(
-          new StaticSocketDataProvider(http_fallback_data,
-                                       arraysize(http_fallback_data),
-                                       NULL, 0));
-    helper.AddDataNoSSL(http_fallback.get());
-    HttpNetworkTransaction* trans = helper.trans();
-    TestCompletionCallback callback;
-
-    int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
-    EXPECT_EQ(rv, ERR_IO_PENDING);
-    rv = callback.WaitForResult();
-    const HttpResponseInfo* response = trans->GetResponseInfo();
-    if (GetParam() == SPDYNOSSL || GetParam() == SPDYSSL) {
-      ASSERT_TRUE(response == NULL);
-      return;
-    }
-    if (GetParam() != SPDYNPN)
-      NOTREACHED();
-    ASSERT_TRUE(response != NULL);
-    ASSERT_TRUE(response->headers != NULL);
-    EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
-    std::string response_data;
-    rv = ReadTransaction(trans, &response_data);
-    EXPECT_EQ(OK, rv);
-
-    EXPECT_TRUE(!response->was_fetched_via_spdy);
-    EXPECT_TRUE(!response->was_npn_negotiated);
-    EXPECT_TRUE(response->was_alternate_protocol_available);
-    EXPECT_TRUE(http_fallback->at_read_eof());
-    EXPECT_EQ(0u, data->read_index());
-    EXPECT_EQ(0u, data->write_index());
-    EXPECT_EQ("hello world!!!", response_data);
-  }
-}
-
 // Verify that basic buffering works; when multiple data frames arrive
 // at the same time, ensure that we don't notify a read completion for
 // each data frame individually.
 TEST_P(SpdyNetworkTransactionTest, Buffering) {
   spdy::SpdyFramer framer;
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 4 data frames in a single read.
@@ skipping 1756 matching lines @@
 
     VerifyStreamsClosed(helper);
 
     // Verify the SYN_REPLY.
     EXPECT_TRUE(response.headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
   }
 }
 
 }  // namespace net