Improve HttpStreamFactory NetLog events

net/http/http_stream_factory_impl.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 <string>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 76 matching lines @@
         alternative_proxy_server, net_log);
   }
 };
 
 }  // anonymous namespace
 
 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
                                              bool for_websockets)
     : session_(session),
       job_factory_(new DefaultJobFactory()),
-      for_websockets_(for_websockets) {}
+      for_websockets_(for_websockets),
+      factory_net_log_(
+          NetLogWithSource::Make(session->net_log(),
+                                 NetLogSourceType::HTTP_STREAM_FACTORY)) {}

[mmenke, 2017/01/12 16:35:08]

This isn't really how sources are currently used - currently, they're all short
lived objects.  With this, we'd basically always have objects 0, 1, 2, etc, at
the top (As long as they're used sometime while logging) which are all
HttpStreamFactories.

[+eroman] for his thoughts on this.

[xunjieli, 2017/01/12 18:09:42]

My main motivation for creating a long-lived event is that I would like to
identify HttpStream Jobs that are created for preconnects. 

If we don't pass a NetLog to PreconnectStreams(), preconnects Jobs won't show up
since there isn't a NetLog attached to the HttpStreamFactoryImpl::Request. The
JobController for these preconnects Jobs won't show up as well.

Non-preconnects Jobs are fine, because they have NetLogWithSource from the
URLRequest.

An alternative approach to see/identify preconnects Jobs will be fine for me
too.

 
 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() {
   DCHECK(request_map_.empty());
   DCHECK(spdy_session_request_map_.empty());
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
@@ skipping 40 matching lines @@
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     WebSocketHandshakeStreamBase::CreateHelper*
         websocket_handshake_stream_create_helper,
     HttpStreamRequest::StreamType stream_type,
     const NetLogWithSource& net_log) {
   JobController* job_controller =
-      new JobController(this, delegate, session_, job_factory_.get());
+      new JobController(this, delegate, session_, job_factory_.get(),
+                        /*is_preconnect=*/false, net_log);
   job_controller_set_.insert(base::WrapUnique(job_controller));
 
   Request* request = job_controller->Start(
-      request_info, delegate, websocket_handshake_stream_create_helper, net_log,
+      request_info, delegate, websocket_handshake_stream_create_helper,
       stream_type, priority, server_ssl_config, proxy_ssl_config);
 
   return request;
 }
 
 void HttpStreamFactoryImpl::PreconnectStreams(
     int num_streams,
     const HttpRequestInfo& request_info) {
   SSLConfig server_ssl_config;
   SSLConfig proxy_ssl_config;
   session_->GetSSLConfig(request_info, &server_ssl_config, &proxy_ssl_config);
   // All preconnects should perform EV certificate verification.
   server_ssl_config.verify_ev_cert = true;
   proxy_ssl_config.verify_ev_cert = true;
 
   DCHECK(!for_websockets_);
 
   JobController* job_controller =
-      new JobController(this, nullptr, session_, job_factory_.get());
+      new JobController(this, nullptr, session_, job_factory_.get(),
+                        /*is_preconnect=*/true, factory_net_log_);
   job_controller_set_.insert(base::WrapUnique(job_controller));
   job_controller->Preconnect(num_streams, request_info, server_ssl_config,
                              proxy_ssl_config);
 }
 
 const HostMappingRules* HttpStreamFactoryImpl::GetHostMappingRules() const {
   return session_->params().host_mapping_rules;
 }
 
 void HttpStreamFactoryImpl::OnNewSpdySessionReady(
     const base::WeakPtr<SpdySession>& spdy_session,
     bool direct,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     bool was_alpn_negotiated,
     NextProto negotiated_protocol,
-    bool using_spdy,
-    const NetLogWithSource& net_log) {
+    bool using_spdy) {
   while (true) {
     if (!spdy_session)
       break;
     const SpdySessionKey& spdy_session_key = spdy_session->spdy_session_key();
     // Each iteration may empty out the RequestSet for |spdy_session_key| in
     // |spdy_session_request_map_|. So each time, check for RequestSet and use
     // the first one.
     //
     // TODO(willchan): If it's important, switch RequestSet out for a FIFO
     // queue (Order by priority first, then FIFO within same priority). Unclear
@@ skipping 86 matching lines @@
   DCHECK(!host_port_pair.IsEmpty());
 
   url::SchemeHostPort scheme_host_port("https", host_port_pair.host(),
                                        host_port_pair.port());
 
   return session_->http_server_properties()->SupportsRequestPriority(
       scheme_host_port);
 }
 
 }  // namespace net