Change a number of SPDY unittests from http to https.

net/spdy/spdy_network_transaction_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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 43 matching lines @@
 
 namespace net {
 
 namespace {
 
 using testing::Each;
 using testing::Eq;
 
 const int32_t kBufferSize = SpdyHttpStream::kRequestBodyBufferSize;
 
 enum SpdyNetworkTransactionTestSSLType {

[Ryan Hamilton, 2016/06/28 22:57:35]

Is this really "SSL type" any more? Fix in a followup?

[Bence, 2016/06/30 18:19:53]

Aaaand https://crrev.com/2109593007 fixes it for good.

   // Request an https:// URL and use NPN (or ALPN) to negotiate SPDY during
   // the TLS handshake.
   HTTPS_SPDY_VIA_NPN,
-  // Request and http:// URL to a server that supports SPDY via Alternative
-  // Service on port 443.
-  // See: https//tools.ietf.org/id/draft-ietf-httpbis-alt-svc-06.html
-  HTTP_SPDY_VIA_ALT_SVC,
+  // Request an https:// URL to a server that supports SPDY via Alternative
+  // Service.
+  // See: http://httpwg.org/http-extensions/alt-svc.html.
+  HTTPS_SPDY_VIA_ALT_SVC,
 };
 
 struct SpdyNetworkTransactionTestParams {
   SpdyNetworkTransactionTestParams()
       : protocol(kProtoSPDY31),
         ssl_type(HTTPS_SPDY_VIA_NPN),
         priority_to_dependency(false) {}
 
   SpdyNetworkTransactionTestParams(NextProto protocol,
                                    SpdyNetworkTransactionTestSSLType ssl_type,
                                    bool priority_to_dependency)
       : protocol(protocol),
         ssl_type(ssl_type),
         priority_to_dependency(priority_to_dependency) {}
 
   friend std::ostream& operator<<(std::ostream& os,
                                   const SpdyNetworkTransactionTestParams& p) {
     std::string type_str;
     switch (p.ssl_type) {
-      case HTTP_SPDY_VIA_ALT_SVC:
-        type_str = "HTTP_SPDY_VIA_ALT_SVC";
+      case HTTPS_SPDY_VIA_ALT_SVC:
+        type_str = "HTTPS_SPDY_VIA_ALT_SVC";
         break;
       case HTTPS_SPDY_VIA_NPN:
         type_str = "HTTPS_SPDY_VIA_NPN";
         break;
     }
     os << "{ protocol: " << SSLClientSocket::NextProtoToString(p.protocol)
        << ", ssl_type: " << type_str
        << ", priority_to_dependency: " << p.priority_to_dependency << " }";
     return os;
   }
 
   NextProto protocol;
   SpdyNetworkTransactionTestSSLType ssl_type;
   bool priority_to_dependency;
 };
 
 void UpdateSpdySessionDependencies(SpdyNetworkTransactionTestParams test_params,
                                    SpdySessionDependencies* session_deps) {
-  if (test_params.ssl_type == HTTP_SPDY_VIA_ALT_SVC) {
+  if (test_params.ssl_type == HTTPS_SPDY_VIA_ALT_SVC) {
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     session_deps->http_server_properties->SetAlternativeService(
-        url::SchemeHostPort("http", "www.example.org", 80),
+        url::SchemeHostPort(GURL(kDefaultUrl)),
         AlternativeService(AlternateProtocolFromNextProto(test_params.protocol),
-                           "www.example.org", 443),
+                           "mail.example.org", 443),
         expiration);
   }
   session_deps->enable_priority_dependencies =
       test_params.priority_to_dependency;
 }
 
 std::unique_ptr<SpdySessionDependencies> CreateSpdySessionDependencies(
     SpdyNetworkTransactionTestParams test_params) {
   std::unique_ptr<SpdySessionDependencies> session_deps(
       new SpdySessionDependencies(test_params.protocol));
@@ skipping 10 matching lines @@
   UpdateSpdySessionDependencies(test_params, session_deps.get());
   return session_deps;
 }
 
 }  // namespace
 
 class SpdyNetworkTransactionTest
     : public ::testing::TestWithParam<SpdyNetworkTransactionTestParams> {
  protected:
   SpdyNetworkTransactionTest()
-      : spdy_util_(GetParam().protocol, GetParam().priority_to_dependency) {
-    spdy_util_.set_default_url(GURL(GetDefaultUrl()));
-  }
+      : default_url_(kDefaultUrl),
+        host_port_pair_(HostPortPair::FromURL(default_url_)),
+        spdy_util_(GetParam().protocol, GetParam().priority_to_dependency) {}
 
   virtual ~SpdyNetworkTransactionTest() {
     // UploadDataStream may post a deletion tasks back to the message loop on
     // destruction.
     upload_data_stream_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void SetUp() override {
     get_request_initialized_ = false;
@@ skipping 20 matching lines @@
         std::unique_ptr<SpdySessionDependencies> session_deps)
         : request_(request),
           priority_(priority),
           session_deps_(session_deps.get() == NULL
                             ? CreateSpdySessionDependencies(test_params)
                             : std::move(session_deps)),
           session_(
               SpdySessionDependencies::SpdyCreateSession(session_deps_.get())),
           log_(log),
           test_params_(test_params),
-          port_(443),
           spdy_enabled_(true) {}
 
     ~NormalSpdyTransactionHelper() {
       // Any test which doesn't close the socket by sending it an EOF will
       // have a valid session left open, which leaks the entire session pool.
       // This is just fine - in fact, some of our tests intentionally do this
       // so that we can check consistency of the SpdySessionPool as the test
       // finishes.  If we had put an EOF on the socket, the SpdySession would
       // have closed and we wouldn't be able to check the consistency.
 
       // Forcefully close existing sessions here.
       session()->spdy_session_pool()->CloseAllSessions();
     }
 
     void SetSpdyDisabled() {
       spdy_enabled_ = false;
-      port_ = test_params_.ssl_type == HTTP_SPDY_VIA_ALT_SVC ? 80 : 443;
     }
 
     void RunPreTestSetup() {
       if (!session_deps_.get())
         session_deps_ = CreateSpdySessionDependencies(test_params_);
       if (!session_.get()) {
         session_ = SpdySessionDependencies::SpdyCreateSession(
             session_deps_.get());
       }
 
@@ skipping 42 matching lines @@
         EXPECT_TRUE(response->was_npn_negotiated);
       } else {
         EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
         EXPECT_FALSE(response->was_fetched_via_spdy);
         // If SPDY is disabled, an HTTP request should not be diverted
         // over an SSL session.
         EXPECT_EQ(request_.url.SchemeIs("https"),
                   response->was_npn_negotiated);
       }
       EXPECT_EQ("127.0.0.1", response->socket_address.host());
-      EXPECT_EQ(port_, response->socket_address.port());
+      EXPECT_EQ(443, response->socket_address.port());
       output_.status_line = response->headers->GetStatusLine();
       output_.response_info = *response;  // Make a copy so we can verify.
       output_.rv = ReadTransaction(trans_.get(), &output_.response_data);
     }
 
     void FinishDefaultTestWithoutVerification() {
       output_.rv = callback_.WaitForResult();
       if (output_.rv != OK)
         session_->spdy_session_pool()->CloseCurrentSessions(ERR_ABORTED);
     }
@@ skipping 51 matching lines @@
       if (ssl_provider->next_proto_status ==
           SSLClientSocket::kNextProtoUnsupported) {
         ssl_provider->SetNextProto(test_params_.protocol);
       }
 
       session_deps_->socket_factory->AddSSLSocketDataProvider(
           ssl_provider.get());
       ssl_vector_.push_back(std::move(ssl_provider));
 
       session_deps_->socket_factory->AddSocketDataProvider(data);
-      if (test_params_.ssl_type == HTTP_SPDY_VIA_ALT_SVC) {
+      if (test_params_.ssl_type == HTTPS_SPDY_VIA_ALT_SVC) {
         MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
         std::unique_ptr<StaticSocketDataProvider> hanging_non_alt_svc_socket(
             base::WrapUnique(new StaticSocketDataProvider(NULL, 0, NULL, 0)));
         hanging_non_alt_svc_socket->set_connect_data(hanging_connect);
         session_deps_->socket_factory->AddSocketDataProvider(
             hanging_non_alt_svc_socket.get());
         alternate_vector_.push_back(std::move(hanging_non_alt_svc_socket));
       }
     }
 
     void SetSession(std::unique_ptr<HttpNetworkSession> session) {
       session_ = std::move(session);
     }
     HttpNetworkTransaction* trans() { return trans_.get(); }
     void ResetTrans() { trans_.reset(); }
     TransactionHelperResult& output() { return output_; }
     const HttpRequestInfo& request() const { return request_; }
     HttpNetworkSession* session() const { return session_.get(); }
     std::unique_ptr<SpdySessionDependencies>& session_deps() {
       return session_deps_;
     }
-    int port() const { return port_; }
     SpdyNetworkTransactionTestParams test_params() const {
       return test_params_;
     }
 
    private:
     typedef std::vector<SocketDataProvider*> DataVector;
     typedef std::vector<std::unique_ptr<SSLSocketDataProvider>> SSLVector;
     typedef std::vector<std::unique_ptr<SocketDataProvider>> AlternateVector;
     HttpRequestInfo request_;
     RequestPriority priority_;
     std::unique_ptr<SpdySessionDependencies> session_deps_;
     std::unique_ptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
     std::unique_ptr<SocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback_;
     std::unique_ptr<HttpNetworkTransaction> trans_;
     std::unique_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
     AlternateVector alternate_vector_;
     const BoundNetLog log_;
     SpdyNetworkTransactionTestParams test_params_;
-    int port_;
     bool spdy_enabled_;
   };
 
   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
                                              int expected_status);
 
   void ConnectStatusHelper(const MockRead& status);
 
   const HttpRequestInfo& CreateGetPushRequest() {
     get_push_request_.method = "GET";
     get_push_request_.url = GURL(GetDefaultUrlWithPath("/foo.dat"));
     get_push_request_.load_flags = 0;
     return get_push_request_;
   }
 
   const HttpRequestInfo& CreateGetRequest() {
     if (!get_request_initialized_) {
       get_request_.method = "GET";
-      get_request_.url = GURL(GetDefaultUrl());
+      get_request_.url = default_url_;
       get_request_.load_flags = 0;
       get_request_initialized_ = true;
     }
     return get_request_;
   }
 
   const HttpRequestInfo& CreateGetRequestWithUserAgent() {
     if (!get_request_initialized_) {
       get_request_.method = "GET";
-      get_request_.url = GURL(GetDefaultUrl());
+      get_request_.url = default_url_;
       get_request_.load_flags = 0;
       get_request_.extra_headers.SetHeader("User-Agent", "Chrome");
       get_request_initialized_ = true;
     }
     return get_request_;
   }
 
   const HttpRequestInfo& CreatePostRequest() {
     if (!post_request_initialized_) {
       std::vector<std::unique_ptr<UploadElementReader>> element_readers;
       element_readers.push_back(base::WrapUnique(
           new UploadBytesElementReader(kUploadData, kUploadDataSize)));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
-      post_request_.url = GURL(GetDefaultUrl());
+      post_request_.url = default_url_;
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
 
   const HttpRequestInfo& CreateFilePostRequest() {
     if (!post_request_initialized_) {
       base::FilePath file_path;
       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 
       std::vector<std::unique_ptr<UploadElementReader>> element_readers;
       element_readers.push_back(base::WrapUnique(new UploadFileElementReader(
           base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
           kUploadDataSize, base::Time())));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
-      post_request_.url = GURL(GetDefaultUrl());
+      post_request_.url = default_url_;
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
 
   const HttpRequestInfo& CreateUnreadableFilePostRequest() {
     if (post_request_initialized_)
       return post_request_;
 
     base::FilePath file_path;
     CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
     CHECK_EQ(static_cast<int>(kUploadDataSize),
              base::WriteFile(file_path, kUploadData, kUploadDataSize));
     CHECK(base::MakeFileUnreadable(file_path));
 
     std::vector<std::unique_ptr<UploadElementReader>> element_readers;
     element_readers.push_back(base::WrapUnique(new UploadFileElementReader(
         base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
         kUploadDataSize, base::Time())));
     upload_data_stream_.reset(
         new ElementsUploadDataStream(std::move(element_readers), 0));
 
     post_request_.method = "POST";
-    post_request_.url = GURL(GetDefaultUrl());
+    post_request_.url = default_url_;
     post_request_.upload_data_stream = upload_data_stream_.get();
     post_request_initialized_ = true;
     return post_request_;
   }
 
   const HttpRequestInfo& CreateComplexPostRequest() {
     if (!post_request_initialized_) {
       const int kFileRangeOffset = 1;
       const int kFileRangeLength = 3;
       CHECK_LT(kFileRangeOffset + kFileRangeLength, kUploadDataSize);
 
       base::FilePath file_path;
       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 
       std::vector<std::unique_ptr<UploadElementReader>> element_readers;
       element_readers.push_back(base::WrapUnique(
           new UploadBytesElementReader(kUploadData, kFileRangeOffset)));
       element_readers.push_back(base::WrapUnique(new UploadFileElementReader(
           base::ThreadTaskRunnerHandle::Get().get(), file_path,
           kFileRangeOffset, kFileRangeLength, base::Time())));
       element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
           kUploadData + kFileRangeOffset + kFileRangeLength,
           kUploadDataSize - (kFileRangeOffset + kFileRangeLength))));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
-      post_request_.url = GURL(GetDefaultUrl());
+      post_request_.url = default_url_;
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
 
   const HttpRequestInfo& CreateChunkedPostRequest() {
     if (!chunked_post_request_initialized_) {
       upload_chunked_data_stream_.reset(new ChunkedUploadDataStream(0));
       chunked_post_request_.method = "POST";
-      chunked_post_request_.url = GURL(GetDefaultUrl());
+      chunked_post_request_.url = default_url_;
       chunked_post_request_.upload_data_stream =
           upload_chunked_data_stream_.get();
       chunked_post_request_initialized_ = true;
     }
     return chunked_post_request_;
   }
 
   // Read the result of a particular transaction, knowing that we've got
   // multiple transactions in the read pipeline; so as we read, we may have
   // to skip over data destined for other transactions while we consume
@@ skipping 16 matching lines @@
       bytes_read += rv;
     }
     return bytes_read;
   }
 
   void VerifyStreamsClosed(const NormalSpdyTransactionHelper& helper) {
     // This lengthy block is reaching into the pool to dig out the active
     // session.  Once we have the session, we verify that the streams are
     // all closed and not leaked at this point.
     const GURL& url = helper.request().url;
-    HostPortPair host_port_pair(url.host(), 443);
-    SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
+    SpdySessionKey key(HostPortPair::FromURL(url), ProxyServer::Direct(),
                        PRIVACY_MODE_DISABLED);
     BoundNetLog log;
     HttpNetworkSession* session = helper.session();
     base::WeakPtr<SpdySession> spdy_session =
         session->spdy_session_pool()->FindAvailableSession(key, url, log);
     ASSERT_TRUE(spdy_session);
     EXPECT_EQ(0u, spdy_session->num_active_streams());
     EXPECT_EQ(0u, spdy_session->num_unclaimed_pushed_streams());
   }
 
@@ skipping 78 matching lines @@
     request.load_flags = 0;
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     callback.WaitForResult();
   }
 
   ChunkedUploadDataStream* upload_chunked_data_stream() const {
     return upload_chunked_data_stream_.get();
   }
 
-  const char* GetDefaultUrl() {
-    switch (GetParam().ssl_type) {
-      case HTTP_SPDY_VIA_ALT_SVC:
-        return "http://www.example.org";
-      case HTTPS_SPDY_VIA_NPN:
-        return "https://www.example.org";
-      default:
-        NOTREACHED();
-        return "";
-    }
+  std::string GetDefaultUrlWithPath(const char* path) {
+    return std::string(kDefaultUrl) + path;
   }
 
-  std::string GetDefaultUrlWithPath(const char* path) {
-    return std::string(GetDefaultUrl()) + path;
-  }
-
+  const GURL default_url_;
+  const HostPortPair host_port_pair_;
   SpdyTestUtil spdy_util_;
 
  private:
   std::unique_ptr<ChunkedUploadDataStream> upload_chunked_data_stream_;
   std::unique_ptr<UploadDataStream> upload_data_stream_;
   bool get_request_initialized_;
   bool post_request_initialized_;
   bool chunked_post_request_initialized_;
   HttpRequestInfo get_request_;
   HttpRequestInfo post_request_;
   HttpRequestInfo chunked_post_request_;
   HttpRequestInfo get_push_request_;
   base::ScopedTempDir temp_dir_;
 };
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different connection types: SPDY after NPN
 // negotiation, SPDY without SSL, and SPDY with SSL.
 //
 // TODO(akalin): Use ::testing::Combine() when we are able to use
 // <tr1/tuple>.
 INSTANTIATE_TEST_CASE_P(
     Spdy,
     SpdyNetworkTransactionTest,
     ::testing::Values(
         SpdyNetworkTransactionTestParams(kProtoSPDY31,
                                          HTTPS_SPDY_VIA_NPN,
                                          false),
         SpdyNetworkTransactionTestParams(kProtoSPDY31,
-                                         HTTP_SPDY_VIA_ALT_SVC,
+                                         HTTPS_SPDY_VIA_ALT_SVC,
                                          false),
         SpdyNetworkTransactionTestParams(kProtoHTTP2,
                                          HTTPS_SPDY_VIA_NPN,
                                          false),
         SpdyNetworkTransactionTestParams(kProtoHTTP2, HTTPS_SPDY_VIA_NPN, true),
         SpdyNetworkTransactionTestParams(kProtoHTTP2,
-                                         HTTP_SPDY_VIA_ALT_SVC,
+                                         HTTPS_SPDY_VIA_ALT_SVC,
                                          false),
         SpdyNetworkTransactionTestParams(kProtoHTTP2,
-                                         HTTP_SPDY_VIA_ALT_SVC,
+                                         HTTPS_SPDY_VIA_ALT_SVC,
                                          true)));
 
 // Verify HttpNetworkTransaction constructor.
 TEST_P(SpdyNetworkTransactionTest, Constructor) {
   std::unique_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(GetParam()));
   std::unique_ptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
   std::unique_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
@@ skipping 23 matching lines @@
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) {
   for (RequestPriority p = MINIMUM_PRIORITY; p <= MAXIMUM_PRIORITY;
        p = RequestPriority(p + 1)) {
     SpdyTestUtil spdy_test_util(GetParam().protocol,
                                 GetParam().priority_to_dependency);
-    spdy_test_util.set_default_url(GURL(GetDefaultUrl()));
 
     // Construct the request.
     std::unique_ptr<SpdySerializedFrame> req(
         spdy_test_util.ConstructSpdyGet(nullptr, 0, 1, p, true));
     MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     SpdyPriority spdy_prio = 0;
     EXPECT_TRUE(
         GetSpdyPriority(spdy_test_util.spdy_version(), *req, &spdy_prio));
     // this repeats the RequestPriority-->SpdyPriority mapping from
@@ skipping 894 matching lines @@
   EXPECT_EQ(ERR_CONNECTION_RESET, out.rv);
 
   helper.VerifyDataConsumed();
 }
 
 // Test that a simple PUT request works.
 TEST_P(SpdyNetworkTransactionTest, Put) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "PUT";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
 
   SpdyHeaderBlock put_headers(
-      spdy_util_.ConstructPutHeaderBlock(GetDefaultUrl(), 0));
+      spdy_util_.ConstructPutHeaderBlock(kDefaultUrl, 0));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(put_headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
@@ skipping 11 matching lines @@
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
 }
 
 // Test that a simple HEAD request works.
 TEST_P(SpdyNetworkTransactionTest, Head) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "HEAD";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
 
   SpdyHeaderBlock head_headers(
-      spdy_util_.ConstructHeadHeaderBlock(GetDefaultUrl(), 0));
+      spdy_util_.ConstructHeadHeaderBlock(kDefaultUrl, 0));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(head_headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*resp, 1),
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, Post) {
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, kUploadDataSize, LOWEST, NULL, 0));
+      kDefaultUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
       CreateMockRead(*resp, 2),
       CreateMockRead(*body, 3),
       MockRead(ASYNC, 0, 4)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreatePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a POST with a file works.
 TEST_P(SpdyNetworkTransactionTest, FilePost) {
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, kUploadDataSize, LOWEST, NULL, 0));
+      kDefaultUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
       CreateMockRead(*resp, 2),
@@ skipping 29 matching lines @@
   helper.RunDefaultTest();
 
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataNotConsumed();
   EXPECT_EQ(ERR_ACCESS_DENIED, helper.output().rv);
 }
 
 // Test that a complex POST works.
 TEST_P(SpdyNetworkTransactionTest, ComplexPost) {
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, kUploadDataSize, LOWEST, NULL, 0));
+      kDefaultUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
       CreateMockRead(*resp, 2),
@@ skipping 104 matching lines @@
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ(expected_response, out.response_data);
 }
 
 // Test that a POST without any post data works.
 TEST_P(SpdyNetworkTransactionTest, NullPost) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   // Create an empty UploadData.
   request.upload_data_stream = NULL;
 
   // When request.upload_data_stream is NULL for post, content-length is
   // expected to be 0.
   SpdyHeaderBlock req_block(
-      spdy_util_.ConstructPostHeaderBlock(GetDefaultUrl(), 0));
+      spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, 0));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(req_block), LOWEST, true));
 
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
@@ skipping 18 matching lines @@
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, EmptyPost) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
   // Create an empty UploadDataStream.
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   ElementsUploadDataStream stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   request.upload_data_stream = &stream;
 
   const uint64_t kContentLength = 0;
 
   SpdyHeaderBlock req_block(
-      spdy_util_.ConstructPostHeaderBlock(GetDefaultUrl(), kContentLength));
+      spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kContentLength));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(req_block), LOWEST, true));
 
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
@@ skipping 322 matching lines @@
   helper.ResetTrans();
   base::RunLoop().RunUntilIdle();
 
   helper.VerifyDataConsumed();
 }
 
 // Verify that the client can correctly deal with the user callback attempting
 // to start another transaction on a session that is closing down. See
 // http://crbug.com/47455
 TEST_P(SpdyNetworkTransactionTest, StartTransactionOnReadCallback) {
+  if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
+    return;
+
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req)};
   MockWrite writes2[] = {CreateMockWrite(*req, 0)};
 
   // The indicated length of this frame is longer than its actual length. When
   // the session receives an empty frame after this one, it shuts down the
   // session, and calls the read callback with the incomplete data.
   const uint8_t kGetBodyFrame2[] = {
       0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00,
@@ skipping 29 matching lines @@
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   const int kSize = 3000;
   scoped_refptr<IOBuffer> buf(new IOBuffer(kSize));
   rv = trans->Read(
       buf.get(), kSize,
       base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback,
-                 helper.session(), GURL(GetDefaultUrl())));
+                 helper.session(), default_url_));
   ASSERT_EQ(ERR_IO_PENDING, rv);
   // This forces an err_IO_pending, which sets the callback.
   data.Resume();
   data.RunUntilPaused();
 
   // This finishes the read.
   data.Resume();
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
@@ skipping 43 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data.Resume();
 
   // Finish running rest of tasks.
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
 // Send a spdy request to www.example.org that gets redirected to www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, DISABLED_RedirectGetRequest) {
-  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
 
   // Setup writes/reads to www.example.org
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReplyRedirect(1));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
@@ skipping 26 matching lines @@
   };
 
   SequencedSocketData data2(reads2, arraysize(reads2), writes2,
                             arraysize(writes2));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   TestDelegate d;
   {
     SpdyURLRequestContext spdy_url_request_context(GetParam().protocol);
     std::unique_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
-        GURL(GetDefaultUrl()), DEFAULT_PRIORITY, &d));
+        default_url_, DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data);
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data2);
 
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     std::string contents("hello!");
     EXPECT_EQ(contents, d.data_received());
   }
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data2.AllReadDataConsumed());
   EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 // Send a spdy request to www.example.org. Get a pushed stream that redirects to
 // www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, DISABLED_RedirectServerPush) {
-  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
 
   // Setup writes/reads to www.example.org
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> rep(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str(),
@@ skipping 36 matching lines @@
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   SequencedSocketData data2(reads2, arraysize(reads2), writes2,
                             arraysize(writes2));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   TestDelegate d;
   TestDelegate d2;
   SpdyURLRequestContext spdy_url_request_context(GetParam().protocol);
   {
     std::unique_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
-        GURL(GetDefaultUrl()), DEFAULT_PRIORITY, &d));
+        default_url_, DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, d.received_redirect_count());
     std::string contents("hello!");
     EXPECT_EQ(contents, d.data_received());
 
@@ skipping 687 matching lines @@
   test_cases[0].expected_headers["hello"] = "bye";
   test_cases[1].expected_headers["hello"] = "bye";
   test_cases[2].expected_headers["hello"] = "bye";
 
   test_cases[0].expected_headers["cookie"] = base::StringPiece("val1\0val2", 9);
   test_cases[2].expected_headers["cookie"] = "val1,val2";
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SpdyTestUtil spdy_test_util(GetParam().protocol,
                                 GetParam().priority_to_dependency);
-    spdy_test_util.set_default_url(GURL(GetDefaultUrl()));
     std::unique_ptr<SpdySerializedFrame> req(
         spdy_test_util.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
     MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     std::unique_ptr<SpdySerializedFrame> resp(
         spdy_test_util.ConstructSpdyGetSynReply(test_cases[i].extra_headers,
                                                 test_cases[i].num_headers, 1));
     std::unique_ptr<SpdySerializedFrame> body(
         spdy_test_util.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
@@ skipping 69 matching lines @@
        true,
        {2, 4},
        {{"friend", "barney", "enemy", "snaggletooth", NULL},
         {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
          "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary",
          "friend,enemy", NULL}}}};
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SpdyTestUtil spdy_test_util(GetParam().protocol,
                                 GetParam().priority_to_dependency);
-    spdy_test_util.set_default_url(GURL(GetDefaultUrl()));
 
     // Construct the request.
     std::unique_ptr<SpdySerializedFrame> frame_req(
         spdy_test_util.ConstructSpdyGet(test_cases[i].extra_headers[0],
                                         test_cases[i].num_headers[0], 1, LOWEST,
                                         true));
 
     MockWrite writes[] = {
         CreateMockWrite(*frame_req, 0),
     };
@@ skipping 77 matching lines @@
       },
       // SYN_REPLY with no headers
       {
           0, {NULL},
       },
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SpdyTestUtil spdy_test_util(GetParam().protocol,
                                 GetParam().priority_to_dependency);
-    spdy_test_util.set_default_url(GURL(GetDefaultUrl()));
 
     std::unique_ptr<SpdySerializedFrame> req(
         spdy_test_util.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
     std::unique_ptr<SpdySerializedFrame> rst(
         spdy_test_util.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
     MockWrite writes[] = {
         CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
     };
 
     // Construct the reply.
@@ skipping 266 matching lines @@
 
   base::ListValue* header_list;
   ASSERT_TRUE(entries[pos].params.get());
   ASSERT_TRUE(entries[pos].params->GetList("headers", &header_list));
 
   std::vector<std::string> expected;
   expected.push_back(std::string(spdy_util_.GetHostKey()) +
                      ": www.example.org");
   expected.push_back(std::string(spdy_util_.GetPathKey()) + ": /");
   expected.push_back(std::string(spdy_util_.GetSchemeKey()) + ": " +
-                     spdy_util_.default_url().scheme());
+                     default_url_.scheme());
   expected.push_back(std::string(spdy_util_.GetMethodKey()) + ": GET");
   expected.push_back("user-agent: Chrome");
   if (spdy_util_.spdy_version() < HTTP2) {
     // HTTP/2 eliminates use of the :version header.
     expected.push_back(std::string(spdy_util_.GetVersionKey()) + ": HTTP/1.1");
   }
   EXPECT_EQ(expected.size(), header_list->GetSize());
   for (std::vector<std::string>::const_iterator it = expected.begin();
        it != expected.end();
        ++it) {
@@ skipping 452 matching lines @@
       0,                   // Data Length
       DATA_FLAG_NONE       // Data Flags
   };
 
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      net_log, GetParam(), NULL);
   helper.RunPreTestSetup();
 
   // Verify that no settings exist initially.
-  HostPortPair host_port_pair("www.example.org", helper.port());
-  url::SchemeHostPort spdy_server("https", host_port_pair.host(),
-                                  host_port_pair.port());
-
+  url::SchemeHostPort spdy_server(default_url_);
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   EXPECT_TRUE(spdy_session_pool->http_server_properties()
                   ->GetSpdySettings(spdy_server)
                   .empty());
 
   // Construct the request.
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
@@ skipping 91 matching lines @@
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      net_log, GetParam(), NULL);
   helper.RunPreTestSetup();
 
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
 
   SpdySessionPoolPeer pool_peer(spdy_session_pool);
   pool_peer.SetEnableSendingInitialData(true);
 
   // Verify that no settings exist initially.
-  HostPortPair host_port_pair("www.example.org", helper.port());
-  url::SchemeHostPort spdy_server("https", host_port_pair.host(),
-                                  host_port_pair.port());
+  url::SchemeHostPort spdy_server(default_url_);
   EXPECT_TRUE(spdy_session_pool->http_server_properties()
                   ->GetSpdySettings(spdy_server)
                   .empty());
 
   const SpdySettingsIds kSampleId1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
   const SpdySettingsIds kSampleId2 = SETTINGS_INITIAL_WINDOW_SIZE;
   unsigned int kSampleValue2 = 0x0c0c0c0c;
 
   // First add a persisted setting.
@@ skipping 163 matching lines @@
   // HTTP_1_1_REQUIRED is only supported by HTTP/2.
   if (spdy_util_.spdy_version() < HTTP2)
     return;
   // HTTP_1_1_REQUIRED implementation relies on the assumption that HTTP/2 is
   // only spoken over SSL.
   if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
     return;
 
   HttpRequestInfo request;
   request.method = "GET";
-  request.url = GURL("https://www.example.org/");
+  request.url = default_url_;
   std::unique_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(GetParam()));
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), std::move(session_deps));
 
   // First socket: HTTP/2 request rejected with HTTP_1_1_REQUIRED.
-  const char* url = request.url.spec().c_str();
-  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(url));
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes0[] = {CreateMockWrite(*req, 0)};
   std::unique_ptr<SpdySerializedFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
   MockRead reads0[] = {CreateMockRead(*go_away, 1)};
   SequencedSocketData data0(reads0, arraysize(reads0), writes0,
                             arraysize(writes0));
 
   std::unique_ptr<SSLSocketDataProvider> ssl_provider0(
@@ skipping 21 matching lines @@
   std::unique_ptr<SSLSocketDataProvider> ssl_provider1(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect only HTTP/1.1 protocol in SSLConfig.
   ssl_provider1->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
   // Force HTTP/1.1.
   ssl_provider1->SetNextProto(kProtoHTTP11);
   helper.AddDataWithSSLSocketDataProvider(&data1, std::move(ssl_provider1));
 
   HttpServerProperties* http_server_properties =
       helper.session()->spdy_session_pool()->http_server_properties();
-  const HostPortPair host_port_pair = HostPortPair::FromURL(GURL(url));
-  EXPECT_FALSE(http_server_properties->RequiresHTTP11(host_port_pair));
+  EXPECT_FALSE(http_server_properties->RequiresHTTP11(host_port_pair_));
 
   helper.RunPreTestSetup();
   helper.StartDefaultTest();
   helper.FinishDefaultTestWithoutVerification();
   helper.VerifyDataConsumed();
-  EXPECT_TRUE(http_server_properties->RequiresHTTP11(host_port_pair));
+  EXPECT_TRUE(http_server_properties->RequiresHTTP11(host_port_pair_));
 
   const HttpResponseInfo* response = helper.trans()->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1, response->connection_info);
   EXPECT_TRUE(response->was_npn_negotiated);
   EXPECT_TRUE(request.url.SchemeIs("https"));
   EXPECT_EQ("127.0.0.1", response->socket_address.host());
@@ skipping 10 matching lines @@
   // HTTP_1_1_REQUIRED is only supported by HTTP/2.
   if (spdy_util_.spdy_version() < HTTP2)
     return;
   // HTTP_1_1_REQUIRED implementation relies on the assumption that HTTP/2 is
   // only spoken over SSL.
   if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
     return;
 
   HttpRequestInfo request;
   request.method = "GET";
-  request.url = GURL("https://www.example.org/");
+  request.url = default_url_;
   std::unique_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(
           GetParam(),
           ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70")));
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), std::move(session_deps));
 
   // First socket: HTTP/2 CONNECT rejected with HTTP_1_1_REQUIRED.
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyConnect(
@@ skipping 188 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(OK, out.rv);
   out.status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   // Check that the SpdySession is still in the SpdySessionPool.
-  HostPortPair host_port_pair("www.example.org", helper.port());
-  SpdySessionKey session_pool_key_direct(
-      host_port_pair, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
+  SpdySessionKey session_pool_key_direct(host_port_pair_, ProxyServer::Direct(),
+                                         PRIVACY_MODE_DISABLED);
   EXPECT_TRUE(HasSpdySession(spdy_session_pool, session_pool_key_direct));
   SpdySessionKey session_pool_key_proxy(
-      host_port_pair,
+      host_port_pair_,
       ProxyServer::FromURI("www.foo.com", ProxyServer::SCHEME_HTTP),
       PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(HasSpdySession(spdy_session_pool, session_pool_key_proxy));
 
   // New SpdyTestUtil instance for the session that will be used for the
   // proxy connection.
   SpdyTestUtil spdy_util_2(GetParam().protocol,
                            GetParam().priority_to_dependency);
 
   // Set up data for the proxy connection.
@@ skipping 61 matching lines @@
   EXPECT_EQ("hello!", response_data);
 
   helper_proxy.VerifyDataConsumed();
 }
 
 // When we get a TCP-level RST, we need to retry a HttpNetworkTransaction
 // on a new connection, if the connection was previously known to be good.
 // This can happen when a server reboots without saying goodbye, or when
 // we're behind a NAT that masked the RST.
 TEST_P(SpdyNetworkTransactionTest, VerifyRetryOnConnectionReset) {
+  if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
+    return;
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*resp, 1),
       CreateMockRead(*body, 2),
       MockRead(ASYNC, ERR_IO_PENDING, 3),
       MockRead(ASYNC, ERR_CONNECTION_RESET, 4),
   };
@@ skipping 853 matching lines @@
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans0 = helper.trans();
   TestCompletionCallback callback0;
   int rv = trans0->Start(&request, callback0.callback(), log);
   rv = callback0.GetResult(rv);
   EXPECT_EQ(OK, rv);
 
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
-  HostPortPair host_port_pair("www.example.org", 443);
-  SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
+  SpdySessionKey key(host_port_pair_, ProxyServer::Direct(),
                      PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> spdy_session =
       spdy_session_pool->FindAvailableSession(key, GURL(), log);
 
   EXPECT_FALSE(spdy_session->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(1u, spdy_session->unclaimed_pushed_streams_.size());
   EXPECT_EQ(1u,
             spdy_session->unclaimed_pushed_streams_.count(GURL(url_to_push)));
 
   std::unique_ptr<HttpNetworkTransaction> trans1(
@@ skipping 429 matching lines @@
 // TODO(agayev): develop a socket data provider where both, reads and
 // writes are ordered so that writing tests like these are easy and rewrite
 // all these tests using it.  Right now we are working around the
 // limitations as described above and it's not deterministic, tests may
 // fail under specific circumstances.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateReceived) {
   static int kFrameCount = 2;
   std::unique_ptr<std::string> content(
       new std::string(kMaxSpdyFrameChunkSize, 'a'));
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL,
-      0));
+      kDefaultUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(spdy_util_.ConstructSpdyBodyFrame(
       1, content->c_str(), content->size(), false));
   std::unique_ptr<SpdySerializedFrame> body_end(
       spdy_util_.ConstructSpdyBodyFrame(1, content->c_str(), content->size(),
                                         true));
 
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*body, 1),
     CreateMockWrite(*body_end, 2),
@@ skipping 24 matching lines @@
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   for (int i = 0; i < kFrameCount; ++i) {
     element_readers.push_back(base::WrapUnique(
         new UploadBytesElementReader(content->c_str(), content->size())));
   }
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
@@ skipping 158 matching lines @@
 
 // Test that WINDOW_UPDATE frame causing overflow is handled correctly.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateOverflow) {
   // Number of full frames we hope to write (but will not, used to
   // set content-length header correctly)
   static int kFrameCount = 3;
 
   std::unique_ptr<std::string> content(
       new std::string(kMaxSpdyFrameChunkSize, 'a'));
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL,
-      0));
+      kDefaultUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(spdy_util_.ConstructSpdyBodyFrame(
       1, content->c_str(), content->size(), false));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR));
 
   // We're not going to write a data frame with FIN, we'll receive a bad
   // WINDOW_UPDATE while sending a request and will send a RST_STREAM frame.
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*body, 2),
@@ skipping 13 matching lines @@
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   for (int i = 0; i < kFrameCount; ++i) {
     element_readers.push_back(base::WrapUnique(
         new UploadBytesElementReader(content->c_str(), content->size())));
   }
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
@@ skipping 31 matching lines @@
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
   std::string content(kMaxSpdyFrameChunkSize, 'a');
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1,
+      kDefaultUrl, 1,
       /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
       LOWEST, NULL, 0));
 
   // Full frames.
   std::unique_ptr<SpdySerializedFrame> body1(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), content.size(), false));
 
   // Last frame in each upload data buffer.
   std::unique_ptr<SpdySerializedFrame> body2(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
@@ skipping 69 matching lines @@
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
@@ skipping 38 matching lines @@
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
   std::string content(kMaxSpdyFrameChunkSize, 'a');
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1,
+      kDefaultUrl, 1,
       /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
       LOWEST, NULL, 0));
 
   // Full frames.
   std::unique_ptr<SpdySerializedFrame> body1(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), content.size(), false));
 
   // Last frame in each upload data buffer.
   std::unique_ptr<SpdySerializedFrame> body2(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
@@ skipping 79 matching lines @@
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
@@ skipping 45 matching lines @@
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
   std::string content(kMaxSpdyFrameChunkSize, 'a');
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1,
+      kDefaultUrl, 1,
       /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
       LOWEST, NULL, 0));
 
   // Full frames.
   std::unique_ptr<SpdySerializedFrame> body1(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), content.size(), false));
 
   // Last frame in each upload data buffer.
   std::unique_ptr<SpdySerializedFrame> body2(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
@@ skipping 81 matching lines @@
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
@@ skipping 81 matching lines @@
 }
 
 // Regression test for https://crbug.com/493348: request header exceeds 16 kB
 // and thus sent in multiple frames when using HTTP/2.
 TEST_P(SpdyNetworkTransactionTest, LargeRequest) {
   const std::string kKey("foo");
   const std::string kValue(1 << 15, 'z');
 
   HttpRequestInfo request;
   request.method = "GET";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   request.extra_headers.SetHeader(kKey, kValue);
 
-  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   headers[kKey] = kValue;
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
@@ skipping 10 matching lines @@
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Regression test for https://crbug.com/535629: response header exceeds 16 kB.
 TEST_P(SpdyNetworkTransactionTest, LargeResponseHeader) {
-  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   // HPACK decoder implementation limits string literal length to 16 kB.
   const char* response_headers[2];
   const std::string kKey(16 * 1024, 'a');
   response_headers[0] = kKey.data();
   const std::string kValue(16 * 1024, 'b');
   response_headers[1] = kValue.data();
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(response_headers, 1, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*resp, 1), CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   HttpRequestInfo request;
   request.method = "GET";
-  request.url = GURL(GetDefaultUrl());
+  request.url = default_url_;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), nullptr);
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
@@ skipping 17 matching lines @@
     MockRead reads[] = {
         CreateMockRead(*resp, 1),
         CreateMockRead(*body, 2),
         MockRead(ASYNC, 0, 3)  // EOF
     };
 
     SequencedSocketData data(reads, arraysize(reads), writes,
                              arraysize(writes));
     HttpRequestInfo request;
     request.method = "GET";
-    request.url = GURL("https://www.example.org/");
+    request.url = default_url_;
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(OK, out.rv);
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
   }
 };
 
@@ skipping 33 matching lines @@
  protected:
   void RunTLSUsageCheckTest(
       std::unique_ptr<SSLSocketDataProvider> ssl_provider) {
     std::unique_ptr<SpdySerializedFrame> goaway(
         spdy_util_.ConstructSpdyGoAway(0, GOAWAY_INADEQUATE_SECURITY, ""));
     MockWrite writes[] = {CreateMockWrite(*goaway)};
 
     StaticSocketDataProvider data(NULL, 0, writes, arraysize(writes));
     HttpRequestInfo request;
     request.method = "GET";
-    request.url = GURL("https://www.example.org/");
+    request.url = default_url_;
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY, out.rv);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(
     Spdy,
@@ skipping 17 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net