Use a NetLog for test requests sent by about:net-internals

chrome/browser/net/connection_tester.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 "chrome/browser/net/connection_tester.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 65 matching lines @@
         config_service->reset(new net::ProxyConfigServiceFixed(
             net::ProxyConfig::CreateDirect()));
         return net::OK;
       default:
         NOTREACHED();
         return net::ERR_UNEXPECTED;
     }
   }
 
   int Init(const ConnectionTester::Experiment& experiment,
-           scoped_ptr<net::ProxyConfigService>* proxy_config_service) {
+           scoped_ptr<net::ProxyConfigService>* proxy_config_service,
+           net::NetLog* net_log) {
     int rv;
 
     // Create a custom HostResolver for this experiment.
     scoped_ptr<net::HostResolver> host_resolver_tmp;
     rv = CreateHostResolver(experiment.host_resolver_experiment,
                             &host_resolver_tmp);
     if (rv != net::OK)
       return rv;  // Failure.
     storage_.set_host_resolver(host_resolver_tmp.release());
 
@@ skipping 12 matching lines @@
         new net::FtpNetworkLayer(host_resolver()));
     storage_.set_ssl_config_service(new net::SSLConfigServiceDefaults);
     storage_.set_http_auth_handler_factory(
         net::HttpAuthHandlerFactory::CreateDefault(host_resolver()));
     storage_.set_http_server_properties(new net::HttpServerPropertiesImpl);
 
     net::HttpNetworkSession::Params session_params;
     session_params.host_resolver = host_resolver();
     session_params.cert_verifier = cert_verifier();
     session_params.proxy_service = proxy_service();
+    session_params.ssl_config_service = ssl_config_service();
     session_params.http_auth_handler_factory = http_auth_handler_factory();
     session_params.http_server_properties = http_server_properties();
-    session_params.ssl_config_service = ssl_config_service();
+    session_params.net_log = net_log;
     scoped_refptr<net::HttpNetworkSession> network_session(
         new net::HttpNetworkSession(session_params));
     storage_.set_http_transaction_factory(new net::HttpCache(
         network_session,
         net::HttpCache::DefaultBackend::InMemory(0)));
     // In-memory cookie store.
     storage_.set_cookie_store(new net::CookieMonster(NULL, NULL));
 
     return net::OK;
   }
@@ skipping 149 matching lines @@
 }  // namespace
 
 // ConnectionTester::TestRunner ----------------------------------------------
 
 // TestRunner is a helper class for running an individual experiment. It can
 // be deleted any time after it is started, and this will abort the request.
 class ConnectionTester::TestRunner : public net::URLRequest::Delegate {
  public:
   // |tester| must remain alive throughout the TestRunner's lifetime.
   // |tester| will be notified of completion.
-  explicit TestRunner(ConnectionTester* tester)
+  TestRunner(ConnectionTester* tester, net::NetLog* net_log)
       : tester_(tester),
+        net_log_(net_log),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
   // Finish running |experiment| once a ProxyConfigService has been created.
   // In the case of a FirefoxProxyConfigService, this will be called back
   // after disk access has completed.
   void ProxyConfigServiceCreated(
     const Experiment& experiment,
     scoped_ptr<net::ProxyConfigService>* proxy_config_service, int status);
 
   // Starts running |experiment|. Notifies tester->OnExperimentCompleted() when
@@ skipping 13 matching lines @@
   // end of stream).
   void ReadBody(net::URLRequest* request);
 
   // Called when the request has completed (for both success and failure).
   void OnResponseCompleted(net::URLRequest* request);
   void OnExperimentCompletedWithResult(int result);
 
   ConnectionTester* tester_;
   scoped_ptr<ExperimentURLRequestContext> request_context_;
   scoped_ptr<net::URLRequest> request_;
+  net::NetLog* net_log_;
 
   base::WeakPtrFactory<TestRunner> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRunner);
 };
 
 void ConnectionTester::TestRunner::OnResponseStarted(net::URLRequest* request) {
   if (!request->status().is_success()) {
     OnResponseCompleted(request);
     return;
@@ skipping 46 matching lines @@
 
 void ConnectionTester::TestRunner::OnExperimentCompletedWithResult(int result) {
   tester_->OnExperimentCompleted(result);
 }
 
 void ConnectionTester::TestRunner::ProxyConfigServiceCreated(
     const Experiment& experiment,
     scoped_ptr<net::ProxyConfigService>* proxy_config_service,
     int status) {
   if (status == net::OK)
-    status = request_context_->Init(experiment, proxy_config_service);
+    status = request_context_->Init(experiment,
+                                    proxy_config_service,
+                                    net_log_);
   if (status != net::OK) {
     tester_->OnExperimentCompleted(status);
     return;
   }
   // Fetch a request using the experimental context.
   request_.reset(new net::URLRequest(experiment.url,
                                      this,
                                      request_context_.get()));
   request_->Start();
 }
@@ skipping 12 matching lines @@
       experiment.proxy_settings_experiment,
       proxy_config_service, config_service_callback);
   if (rv != net::ERR_IO_PENDING)
     ProxyConfigServiceCreated(experiment, proxy_config_service, rv);
 }
 
 // ConnectionTester ----------------------------------------------------------
 
 ConnectionTester::ConnectionTester(
     Delegate* delegate,
-    net::URLRequestContext* proxy_request_context)
-    : delegate_(delegate), proxy_request_context_(proxy_request_context) {
+    net::URLRequestContext* proxy_request_context,
+    net::NetLog* net_log)
+    : delegate_(delegate),
+      proxy_request_context_(proxy_request_context),
+      net_log_(net_log) {
   DCHECK(delegate);
   DCHECK(proxy_request_context);
 }
 
 ConnectionTester::~ConnectionTester() {
   // Cancellation happens automatically by deleting test_runner_.
 }
 
 void ConnectionTester::RunAllTests(const GURL& url) {
   // Select all possible experiments to run. (In no particular order).
@@ skipping 59 matching lines @@
     }
   }
 }
 
 void ConnectionTester::StartNextExperiment() {
   DCHECK(!remaining_experiments_.empty());
   DCHECK(!current_test_runner_.get());
 
   delegate_->OnStartConnectionTestExperiment(current_experiment());
 
-  current_test_runner_.reset(new TestRunner(this));
+  current_test_runner_.reset(new TestRunner(this, net_log_));
   current_test_runner_->Run(current_experiment());
 }
 
 void ConnectionTester::OnExperimentCompleted(int result) {
   Experiment current = current_experiment();
 
   // Advance to the next experiment.
   remaining_experiments_.erase(remaining_experiments_.begin());
   current_test_runner_.reset();
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }