Rename net::BidirectionalStream*Job to net::BidirectionalStream*Impl

net/http/http_stream_factory_impl_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_stream_factory_impl.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "net/base/port_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
-#include "net/http/bidirectional_stream_job.h"
+#include "net/http/bidirectional_stream_impl.h"
 #include "net/http/bidirectional_stream_request_info.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream.h"
 #include "net/http/transport_security_state.h"
@@ skipping 20 matching lines @@
 #include "net/test/cert_test_util.h"
 
 // This file can be included from net/http even though
 // it is in net/websockets because it doesn't
 // introduce any link dependency to net/websockets.
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
-class BidirectionalStreamJob;
+class BidirectionalStreamImpl;
 
 namespace {
 
 class MockWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
  public:
   enum StreamType {
     kStreamTypeBasic,
     kStreamTypeSpdy,
   };
 
@@ skipping 108 matching lines @@
       const ProxyInfo& used_proxy_info,
       WebSocketHandshakeStreamBase* stream) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->QuitWhenIdle();
     websocket_stream_.reset(stream);
     used_ssl_config_ = used_ssl_config;
     used_proxy_info_ = used_proxy_info;
   }
 
-  void OnBidirectionalStreamJobReady(const SSLConfig& used_ssl_config,
-                                     const ProxyInfo& used_proxy_info,
-                                     BidirectionalStreamJob* stream) override {
+  void OnBidirectionalStreamImplReady(
+      const SSLConfig& used_ssl_config,
+      const ProxyInfo& used_proxy_info,
+      BidirectionalStreamImpl* stream) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->QuitWhenIdle();
-    bidirectional_stream_job_.reset(stream);
+    bidirectional_stream_impl_.reset(stream);
     used_ssl_config_ = used_ssl_config;
     used_proxy_info_ = used_proxy_info;
   }
 
   void OnStreamFailed(int status,
                       const SSLConfig& used_ssl_config,
                       SSLFailureState ssl_failure_state) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->QuitWhenIdle();
@@ skipping 37 matching lines @@
   }
 
   HttpStream* stream() {
     return stream_.get();
   }
 
   MockWebSocketHandshakeStream* websocket_stream() {
     return static_cast<MockWebSocketHandshakeStream*>(websocket_stream_.get());
   }
 
-  BidirectionalStreamJob* bidirectional_stream_job() {
-    return bidirectional_stream_job_.get();
+  BidirectionalStreamImpl* bidirectional_stream_impl() {
+    return bidirectional_stream_impl_.get();
   }
 
   bool stream_done() const { return stream_done_; }
   int error_status() const { return error_status_; }
 
  private:
   bool waiting_for_stream_;
   bool stream_done_;
   scoped_ptr<HttpStream> stream_;
   scoped_ptr<WebSocketHandshakeStreamBase> websocket_stream_;
-  scoped_ptr<BidirectionalStreamJob> bidirectional_stream_job_;
+  scoped_ptr<BidirectionalStreamImpl> bidirectional_stream_impl_;
   SSLConfig used_ssl_config_;
   ProxyInfo used_proxy_info_;
   int error_status_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamRequestWaiter);
 };
 
 class WebSocketSpdyHandshakeStream : public MockWebSocketHandshakeStream {
  public:
   explicit WebSocketSpdyHandshakeStream(
@@ skipping 453 matching lines @@
     const ProxyRetryInfoMap& retry_info =
         session->proxy_service()->proxy_retry_info();
     EXPECT_EQ(1u, retry_info.size()) << mock_error[i];
     EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
     ProxyRetryInfoMap::const_iterator iter = retry_info.find("quic://bad:99");
     EXPECT_TRUE(iter != retry_info.end()) << mock_error[i];
   }
 }
 
-// BidirectionalStreamJob::Delegate to wait until response headers are
+// BidirectionalStreamImpl::Delegate to wait until response headers are
 // received.
-class TestBidirectionalDelegate : public BidirectionalStreamJob::Delegate {
+class TestBidirectionalDelegate : public BidirectionalStreamImpl::Delegate {
  public:
   void WaitUntilDone() { loop_.Run(); }
 
   const SpdyHeaderBlock& response_headers() const { return response_headers_; }
 
  private:
   void OnHeadersSent() override {}
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override {
     response_headers_ = response_headers;
     loop_.Quit();
@@ skipping 696 matching lines @@
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
-TEST_P(HttpStreamFactoryTest, RequestBidirectionalStreamJob) {
+TEST_P(HttpStreamFactoryTest, RequestBidirectionalStreamImpl) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
 
   MockRead mock_read(ASYNC, OK);
   SequencedSocketData socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
   ssl_socket_data.SetNextProto(GetParam());
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 
   HostPortPair host_port_pair("www.google.com", 443);
   scoped_ptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   // Now request a stream.
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
   request_info.load_flags = 0;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
   scoped_ptr<HttpStreamRequest> request(
-      session->http_stream_factory()->RequestBidirectionalStreamJob(
+      session->http_stream_factory()->RequestBidirectionalStreamImpl(
           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   EXPECT_FALSE(waiter.websocket_stream());
   ASSERT_FALSE(waiter.stream());
-  ASSERT_TRUE(waiter.bidirectional_stream_job());
+  ASSERT_TRUE(waiter.bidirectional_stream_impl());
   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetTransportSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSSLSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
   ASSERT_EQ(0u,
@@ skipping 78 matching lines @@
   scoped_ptr<ProxyService> proxy_service_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   HttpNetworkSession::Params params_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
                         HttpStreamFactoryBidirectionalQuicTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(HttpStreamFactoryBidirectionalQuicTest,
-       RequestBidirectionalStreamJobQuicAlternative) {
+       RequestBidirectionalStreamImplQuicAlternative) {
   GURL url = GURL("https://www.example.org");
 
   MockQuicData mock_quic_data;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
   size_t spdy_headers_frame_length;
   mock_quic_data.AddWrite(packet_maker().MakeRequestHeadersPacket(
       1, test::kClientDataStreamId1, /*should_include_version=*/true,
       /*fin=*/true, priority,
       packet_maker().GetRequestHeaders("GET", "https", "/"),
@@ skipping 21 matching lines @@
 
   // Now request a stream.
   SSLConfig ssl_config;
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.example.org");
   request_info.load_flags = 0;
 
   StreamRequestWaiter waiter;
   scoped_ptr<HttpStreamRequest> request(
-      session()->http_stream_factory()->RequestBidirectionalStreamJob(
+      session()->http_stream_factory()->RequestBidirectionalStreamImpl(
           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
           BoundNetLog()));
 
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   EXPECT_FALSE(waiter.websocket_stream());
   ASSERT_FALSE(waiter.stream());
-  ASSERT_TRUE(waiter.bidirectional_stream_job());
-  BidirectionalStreamJob* job = waiter.bidirectional_stream_job();
+  ASSERT_TRUE(waiter.bidirectional_stream_impl());
+  BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl();
 
   BidirectionalStreamRequestInfo bidi_request_info;
   bidi_request_info.method = "GET";
   bidi_request_info.url = GURL("https://www.example.org/");
   bidi_request_info.end_stream_on_headers = true;
   bidi_request_info.priority = LOWEST;
 
   TestBidirectionalDelegate delegate;
-  job->Start(&bidi_request_info, BoundNetLog(), &delegate, nullptr);
+  stream_impl->Start(&bidi_request_info, BoundNetLog(), &delegate, nullptr);
   delegate.WaitUntilDone();
 
   scoped_refptr<IOBuffer> buffer = new net::IOBuffer(1);
-  EXPECT_EQ(OK, job->ReadData(buffer.get(), 1));
-  EXPECT_EQ(kProtoQUIC1SPDY3, job->GetProtocol());
+  EXPECT_EQ(OK, stream_impl->ReadData(buffer.get(), 1));
+  EXPECT_EQ(kProtoQUIC1SPDY3, stream_impl->GetProtocol());
   EXPECT_EQ("200", delegate.response_headers().find(":status")->second);
   EXPECT_EQ(1, GetSocketPoolGroupCount(session()->GetTransportSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(session()->GetSSLSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session()->GetTransportSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session()->GetSSLSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
 // Tests that when QUIC is not enabled for bidirectional streaming, HTTP/2 is
 // used instead.
 TEST_P(HttpStreamFactoryBidirectionalQuicTest,
-       RequestBidirectionalStreamJobQuicNotEnabled) {
+       RequestBidirectionalStreamImplQuicNotEnabled) {
   GURL url = GURL("https://www.example.org");
 
   // Make the http job fail.
   scoped_ptr<StaticSocketDataProvider> http_job_data;
   http_job_data.reset(new StaticSocketDataProvider());
   MockConnect failed_connect(ASYNC, ERR_CONNECTION_REFUSED);
   http_job_data->set_connect_data(failed_connect);
   socket_factory().AddSocketDataProvider(http_job_data.get());
   SSLSocketDataProvider ssl_data(ASYNC, OK);
   socket_factory().AddSSLSocketDataProvider(&ssl_data);
 
   // Set up QUIC as alternative_service.
   AddQuicAlternativeService();
   DisableQuicBidirectionalStream();
   Initialize();
 
   // Now request a stream.
   SSLConfig ssl_config;
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.example.org");
   request_info.load_flags = 0;
 
   StreamRequestWaiter waiter;
   scoped_ptr<HttpStreamRequest> request(
-      session()->http_stream_factory()->RequestBidirectionalStreamJob(
+      session()->http_stream_factory()->RequestBidirectionalStreamImpl(
           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
           BoundNetLog()));
 
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   EXPECT_FALSE(waiter.websocket_stream());
   ASSERT_FALSE(waiter.stream());
-  ASSERT_FALSE(waiter.bidirectional_stream_job());
+  ASSERT_FALSE(waiter.bidirectional_stream_impl());
   // Since the alternative service job is not started, we will get the error
   // from the http job.
   ASSERT_EQ(ERR_CONNECTION_REFUSED, waiter.error_status());
 }
 
 // Tests that if Http job fails, but Quic job succeeds, we return
 // BidirectionalStreamQuicImpl.
 TEST_P(HttpStreamFactoryBidirectionalQuicTest,
-       RequestBidirectionalStreamJobHttpJobFailsQuicJobSucceeds) {
+       RequestBidirectionalStreamImplHttpJobFailsQuicJobSucceeds) {
   GURL url = GURL("https://www.example.org");
 
   // Set up Quic data.
   MockQuicData mock_quic_data;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
   size_t spdy_headers_frame_length;
   mock_quic_data.AddWrite(packet_maker().MakeRequestHeadersPacket(
       1, test::kClientDataStreamId1, /*should_include_version=*/true,
       /*fin=*/true, priority,
@@ skipping 22 matching lines @@
 
   // Now request a stream.
   SSLConfig ssl_config;
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.example.org");
   request_info.load_flags = 0;
 
   StreamRequestWaiter waiter;
   scoped_ptr<HttpStreamRequest> request(
-      session()->http_stream_factory()->RequestBidirectionalStreamJob(
+      session()->http_stream_factory()->RequestBidirectionalStreamImpl(
           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
           BoundNetLog()));
 
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   EXPECT_FALSE(waiter.websocket_stream());
   ASSERT_FALSE(waiter.stream());
-  ASSERT_TRUE(waiter.bidirectional_stream_job());
-  BidirectionalStreamJob* job = waiter.bidirectional_stream_job();
+  ASSERT_TRUE(waiter.bidirectional_stream_impl());
+  BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl();
 
   BidirectionalStreamRequestInfo bidi_request_info;
   bidi_request_info.method = "GET";
   bidi_request_info.url = GURL("https://www.example.org/");
   bidi_request_info.end_stream_on_headers = true;
   bidi_request_info.priority = LOWEST;
 
   TestBidirectionalDelegate delegate;
-  job->Start(&bidi_request_info, BoundNetLog(), &delegate, nullptr);
+  stream_impl->Start(&bidi_request_info, BoundNetLog(), &delegate, nullptr);
   delegate.WaitUntilDone();
 
   // Make sure the BidirectionalStream negotiated goes through QUIC.
   scoped_refptr<IOBuffer> buffer = new net::IOBuffer(1);
-  EXPECT_EQ(OK, job->ReadData(buffer.get(), 1));
-  EXPECT_EQ(kProtoQUIC1SPDY3, job->GetProtocol());
+  EXPECT_EQ(OK, stream_impl->ReadData(buffer.get(), 1));
+  EXPECT_EQ(kProtoQUIC1SPDY3, stream_impl->GetProtocol());
   EXPECT_EQ("200", delegate.response_headers().find(":status")->second);
   // There is no Http2 socket pool.
   EXPECT_EQ(0, GetSocketPoolGroupCount(session()->GetTransportSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session()->GetSSLSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session()->GetTransportSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session()->GetSSLSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
-TEST_P(HttpStreamFactoryTest, RequestBidirectionalStreamJobFailure) {
+TEST_P(HttpStreamFactoryTest, RequestBidirectionalStreamImplFailure) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
 
   MockRead mock_read(ASYNC, OK);
   SequencedSocketData socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
 
-  // If HTTP/1 is used, BidirectionalStreamJob should not be obtained.
+  // If HTTP/1 is used, BidirectionalStreamImpl should not be obtained.
   ssl_socket_data.SetNextProto(kProtoHTTP11);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 
   HostPortPair host_port_pair("www.google.com", 443);
   scoped_ptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   // Now request a stream.
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
   request_info.load_flags = 0;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
   scoped_ptr<HttpStreamRequest> request(
-      session->http_stream_factory()->RequestBidirectionalStreamJob(
+      session->http_stream_factory()->RequestBidirectionalStreamImpl(
           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   ASSERT_EQ(ERR_FAILED, waiter.error_status());
   EXPECT_FALSE(waiter.websocket_stream());
   ASSERT_FALSE(waiter.stream());
-  ASSERT_FALSE(waiter.bidirectional_stream_job());
+  ASSERT_FALSE(waiter.bidirectional_stream_impl());
   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetTransportSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSSLSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   ASSERT_EQ(0u,
             static_cast<HttpStreamFactoryImpl*>(session->http_stream_factory())
@@ skipping 198 matching lines @@
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
   // Make sure there is no orphaned job. it is already canceled.
   ASSERT_EQ(0u, static_cast<HttpStreamFactoryImpl*>(
       session->http_stream_factory_for_websocket())->num_orphaned_jobs());
 }
 
 }  // namespace
 
 }  // namespace net