Minor test cleanup.

net/spdy/bidirectional_stream_spdy_impl_unittest.cc

 // Copyright 2016 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/spdy/bidirectional_stream_spdy_impl.h"
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
@@ skipping 186 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
 };
 
 }  // namespace
 
 class BidirectionalStreamSpdyImplTest : public testing::Test {
  public:
   BidirectionalStreamSpdyImplTest()
       : spdy_util_(kProtoHTTP2, true),
         session_deps_(kProtoHTTP2),
+        default_url_(kDefaultUrl),
+        host_port_pair_(HostPortPair::FromURL(default_url_)),
+        key_(host_port_pair_, ProxyServer::Direct(), PRIVACY_MODE_DISABLED),
         ssl_data_(SSLSocketDataProvider(ASYNC, OK)) {
     ssl_data_.SetNextProto(kProtoHTTP2);
     ssl_data_.cert = ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
   }
 
  protected:
   void TearDown() override {
     if (sequenced_data_) {
       EXPECT_TRUE(sequenced_data_->AllReadDataConsumed());
       EXPECT_TRUE(sequenced_data_->AllWriteDataConsumed());
     }
   }
 
   // Initializes the session using SequencedSocketData.
   void InitSession(MockRead* reads,
                    size_t reads_count,
                    MockWrite* writes,
-                   size_t writes_count,
-                   const SpdySessionKey& key) {
+                   size_t writes_count) {
     ASSERT_TRUE(ssl_data_.cert.get());
     session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data_);
     sequenced_data_.reset(
         new SequencedSocketData(reads, reads_count, writes, writes_count));
     session_deps_.socket_factory->AddSocketDataProvider(sequenced_data_.get());
     session_deps_.net_log = net_log_.bound().net_log();
     http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
     session_ =
-        CreateSecureSpdySession(http_session_.get(), key, net_log_.bound());
+        CreateSecureSpdySession(http_session_.get(), key_, net_log_.bound());
   }
 
   BoundTestNetLog net_log_;
   SpdyTestUtil spdy_util_;
   SpdySessionDependencies session_deps_;
+  const GURL default_url_;
+  const HostPortPair host_port_pair_;
+  const SpdySessionKey key_;
   std::unique_ptr<SequencedSocketData> sequenced_data_;
   std::unique_ptr<HttpNetworkSession> http_session_;
   base::WeakPtr<SpdySession> session_;
 
  private:
   SSLSocketDataProvider ssl_data_;
 };
 
 TEST_F(BidirectionalStreamSpdyImplTest, SendDataAfterStreamFailed) {
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      "https://www.example.org", 1, kBodyDataSize * 3, LOW, nullptr, 0));
+      kDefaultUrl, 1, kBodyDataSize * 3, LOW, nullptr, 0));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
 
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
   };
 
   const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(kExtraHeaders, 1, 1));
 
   MockRead reads[] = {
       CreateMockRead(*resp, 1), MockRead(ASYNC, 0, 3),
   };
 
-  HostPortPair host_port_pair("www.example.org", 443);
-  SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
-                     PRIVACY_MODE_DISABLED);
-  InitSession(reads, arraysize(reads), writes, arraysize(writes), key);
+  InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   BidirectionalStreamRequestInfo request_info;
   request_info.method = "POST";
-  request_info.url = GURL("https://www.example.org/");
+  request_info.url = default_url_;
   request_info.extra_headers.SetHeader(net::HttpRequestHeaders::kContentLength,
                                        base::SizeTToString(kBodyDataSize * 3));
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(session_, read_buffer.get(), kReadBufferSize));
   delegate->SetRunUntilCompletion(true);
   delegate->Start(&request_info, net_log_.bound());
   base::RunLoop().RunUntilIdle();
 
@@ skipping 12 matching lines @@
   // because it is sent after SpdyStream::Delegate::OnClose is called.
   EXPECT_EQ(CountWriteBytes(writes, 1), delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
 }
 
 TEST_F(BidirectionalStreamSpdyImplTest, SendDataAfterCancelStream) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      "https://www.example.org", 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
+      kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, kBodyData, kBodyDataSize, DATA_FLAG_NONE));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
 
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*data_frame, 3),
       CreateMockWrite(*rst, 5),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
   std::unique_ptr<SpdySerializedFrame> response_body_frame(
       spdy_util_.ConstructSpdyBodyFrame(1, false));
 
   MockRead reads[] = {
       CreateMockRead(*resp, 1),
       MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a pause.
       MockRead(ASYNC, ERR_IO_PENDING, 4),  // Force a pause.
       MockRead(ASYNC, 0, 6),
   };
 
-  HostPortPair host_port_pair("www.example.org", 443);
-  SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
-                     PRIVACY_MODE_DISABLED);
-  InitSession(reads, arraysize(reads), writes, arraysize(writes), key);
+  InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   BidirectionalStreamRequestInfo request_info;
   request_info.method = "POST";
-  request_info.url = GURL("https://www.example.org/");
+  request_info.url = default_url_;
   request_info.priority = LOWEST;
   request_info.extra_headers.SetHeader(net::HttpRequestHeaders::kContentLength,
                                        base::SizeTToString(kBodyDataSize * 3));
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(session_, read_buffer.get(), kReadBufferSize));
   delegate->set_do_not_start_read(true);
   delegate->Start(&request_info, net_log_.bound());
   // Send the request and receive response headers.
@@ skipping 17 matching lines @@
   EXPECT_FALSE(delegate->on_failed_called());
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   EXPECT_EQ(0, delegate->GetTotalSentBytes());
   EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
 }
 
 }  // namespace net