net: rename BoundNetLog to NetLogWithSource

net/http/http_stream_factory_impl_job_controller_unittest.cc

 // Copyright (c) 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/http/http_stream_factory_impl_job_controller.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 43 matching lines @@
 class FailingHostResolver : public MockHostResolverBase {
  public:
   FailingHostResolver() : MockHostResolverBase(false /*use_caching*/) {}
   ~FailingHostResolver() override {}
 
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               std::unique_ptr<Request>* out_req,
-              const BoundNetLog& net_log) override {
+              const NetLogWithSource& net_log) override {
     return ERR_NAME_NOT_RESOLVED;
   }
 };
 
 class HangingResolver : public MockHostResolverBase {
  public:
   HangingResolver() : MockHostResolverBase(false /*use_caching*/) {}
   ~HangingResolver() override {}
 
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               std::unique_ptr<Request>* out_req,
-              const BoundNetLog& net_log) override {
+              const NetLogWithSource& net_log) override {
     return ERR_IO_PENDING;
   }
 };
 }  // anonymous namespace
 
 class HttpStreamFactoryImplJobPeer {
  public:
   static void Start(HttpStreamFactoryImpl::Job* job,
                     HttpStreamRequest::StreamType stream_type) {
     // Start() is mocked for MockHttpStreamFactoryImplJob.
@@ skipping 99 matching lines @@
       new ProxyService(base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
                        base::WrapUnique(proxy_resolver_factory), nullptr));
   Initialize(false);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
 
   EXPECT_TRUE(job_controller_->main_job());
 
   // There's no other alternative job. Thus when stream failed, it should
   // notify Request of the stream failure.
   EXPECT_CALL(request_delegate_, OnStreamFailed(ERR_FAILED, _)).Times(1);
   job_controller_->OnStreamFailed(job_factory_.main_job(), ERR_FAILED,
                                   SSLConfig());
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest,
        OnStreamReadyWithNoAlternativeJob) {
   ProxyConfig proxy_config;
   proxy_config.set_auto_detect(true);
   // Use asynchronous proxy resolver.
   MockAsyncProxyResolverFactory* proxy_resolver_factory =
       new MockAsyncProxyResolverFactory(false);
   session_deps_.proxy_service.reset(
       new ProxyService(base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
                        base::WrapUnique(proxy_resolver_factory), nullptr));
   Initialize(false);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
 
   // There's no other alternative job. Thus when a stream is ready, it should
   // notify Request.
   HttpStream* http_stream =
       new HttpBasicStream(base::MakeUnique<ClientSocketHandle>(), false, false);
   job_factory_.main_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
@@ skipping 17 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Reset the Request will cancel all the Jobs since there's no Job determined
   // to serve Request yet and JobController will notify the factory to delete
   // itself upon completion.
   request_.reset();
   VerifyBrokenAlternateProtocolMapping(request_info, false);
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
@@ skipping 13 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // We have the main job with unknown status when the alternative job is failed
   // thus should not notify Request of the alternative job's failure. But should
   // notify the main job to mark the alternative job failed.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
   job_controller_->OnStreamFailed(job_factory_.alternative_job(), ERR_FAILED,
                                   SSLConfig());
@@ skipping 23 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Main job succeeds, starts serving Request and it should report status
   // to Request. The alternative job will mark the main job complete and gets
   // orphaned.
   HttpStream* http_stream =
       new HttpBasicStream(base::MakeUnique<ClientSocketHandle>(), false, false);
   job_factory_.main_job()->SetStream(http_stream);
@@ skipping 30 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // |main_job| fails but should not report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
 
   job_controller_->OnStreamFailed(job_factory_.main_job(), ERR_FAILED,
                                   SSLConfig());
 
@@ skipping 24 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // |alternative_job| fails but should not report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
 
   job_controller_->OnStreamFailed(job_factory_.alternative_job(), ERR_FAILED,
                                   SSLConfig());
 
@@ skipping 26 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // |main_job| fails but should not report status to Request.
   // The alternative job will mark the main job complete.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
 
   job_controller_->OnStreamFailed(job_factory_.main_job(), ERR_FAILED,
                                   SSLConfig());
@@ skipping 28 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Wait until OnStreamFailedCallback is executed on the alternative job.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(1);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, InvalidPortForQuic) {
   // Using a restricted port 101 for QUIC should fail and the alternative job
   // should post OnStreamFailedCall on the controller to resume the main job.
   Initialize(false);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 101);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
 
   EXPECT_TRUE(job_factory_.main_job()->is_waiting());
 
   // Wait until OnStreamFailedCallback is executed on the alternative job.
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest,
@@ skipping 24 matching lines @@
   // Set a SPDY alternative service for the server.
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
   // Hack to use different URL for the main job to help differentiate the proxy
   // requests.
   job_factory_.UseDifferentURLForMainJob(GURL("http://www.google.com"));
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   // Both jobs should be created but stalled as proxy resolution not completed.
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   MockAsyncProxyResolver resolver;
   proxy_resolver_factory->pending_requests()[0]->CompleteNowWithForwarder(
       net::OK, &resolver);
 
   // Resolve proxy for the main job which then proceed to wait for the
@@ skipping 41 matching lines @@
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
   // Hack to use different URL for the main job to help differentiate the proxy
   // requests.
   job_factory_.UseDifferentURLForMainJob(GURL("http://www.google.com"));
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   MockAsyncProxyResolver resolver;
   proxy_resolver_factory->pending_requests()[0]->CompleteNowWithForwarder(
       net::OK, &resolver);
 
   // Resolve proxy for the main job which then proceed to wait for the
   // alternative job which is IO_PENDING.
@@ skipping 38 matching lines @@
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   // Set a SPDY alternative service for the server.
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // The alternative job stalls as host resolution hangs when creating the QUIC
   // request and controller should resume the main job after delay.
   // Verify the waiting time for delayed main job.
   EXPECT_CALL(*job_factory_.main_job(), Resume())
       .WillOnce(Invoke(testing::CreateFunctor(
           &JobControllerPeer::VerifyWaitingTimeForMainJob, job_controller_,
@@ skipping 11 matching lines @@
 
   Initialize(true);
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_quic());
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://mail.example.org/");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->main_job()->is_waiting());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(0);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, test_proxy_delegate()->get_alternative_proxy_invocations());
 }
 
 // Verifies that the alternative proxy server job is not created if the main job
 // does not fetch the resource through a proxy.
 TEST_F(HttpStreamFactoryImplJobControllerTest, HttpURLWithNoProxy) {
   // Using hanging resolver will cause the alternative job to hang indefinitely.
   HangingResolver* resolver = new HangingResolver();
   session_deps_.host_resolver.reset(resolver);
 
   Initialize(false);
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_quic());
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://mail.example.org/");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->main_job()->is_waiting());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(0);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, test_proxy_delegate()->get_alternative_proxy_invocations());
 }
@@ skipping 16 matching lines @@
   stats1.srtt = base::TimeDelta::FromMicroseconds(10);
   session_->http_server_properties()->SetServerNetworkStats(
       url::SchemeHostPort(GURL("https://myproxy.org")), stats1);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://mail.example.org/");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->main_job()->is_waiting());
   EXPECT_TRUE(job_controller_->alternative_job());
   EXPECT_TRUE(JobControllerPeer::main_job_is_blocked(job_controller_));
 
   // The alternative proxy server job stalls when connecting to the alternative
   // proxy server, and controller should resume the main job after delay.
   // Verify the waiting time for delayed main job.
   EXPECT_CALL(*job_factory_.main_job(), Resume())
@@ skipping 40 matching lines @@
   stats1.srtt = base::TimeDelta::FromMicroseconds(300 * 1000);
   session_->http_server_properties()->SetServerNetworkStats(
       url::SchemeHostPort(GURL("https://myproxy.org")), stats1);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://mail.example.org/");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
-                             BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job()->is_waiting());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _)).Times(0);
 
   // Since the alternative proxy server job is started in the next message loop,
   // the main job would remain blocked until the alternative proxy starts, and
   // fails.
   EXPECT_CALL(*job_factory_.main_job(), Resume())
       .WillOnce(Invoke(testing::CreateFunctor(
           &JobControllerPeer::VerifyWaitingTimeForMainJob, job_controller_,
           base::TimeDelta::FromMicroseconds(0))));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(job_controller_->alternative_job());
   EXPECT_TRUE(job_controller_->main_job()->is_waiting());
   // Since the main job did not complete successfully, the alternative proxy
   // server should not be marked as bad.
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_valid());
   EXPECT_EQ(1, test_proxy_delegate()->get_alternative_proxy_invocations());
 }
 
 }  // namespace net