Track all jobs associated with an HttpStreamRequest.

net/http/http_stream_factory_impl_job.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_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 32 matching lines @@
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_failure_state.h"
 
 namespace net {
 
 // Returns parameters associated with the start of a HTTP stream job.
 scoped_ptr<base::Value> NetLogHttpStreamJobCallback(
+    const NetLog::Source& source,
     const GURL* original_url,
     const GURL* url,
     const AlternativeService* alternative_service,
     RequestPriority priority,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  if (source.IsValid())
+    source.AddToEventParameters(dict.get());
   dict->SetString("original_url", original_url->GetOrigin().spec());
   dict->SetString("url", url->GetOrigin().spec());
   dict->SetString("alternative_service", alternative_service->ToString());
   dict->SetString("priority", RequestPriorityToString(priority));
   return dict.Pass();
 }
 
 // Returns parameters associated with the Proto (with NPN negotiation) of a HTTP
 // stream.
 scoped_ptr<base::Value> NetLogHttpStreamProtoCallback(
@@ skipping 151 matching lines @@
   if (next_state_ == STATE_WAIT_FOR_JOB_COMPLETE) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&HttpStreamFactoryImpl::Job::OnIOComplete,
                               ptr_factory_.GetWeakPtr(), OK));
   }
 }
 
 void HttpStreamFactoryImpl::Job::Orphan(const Request* request) {
   DCHECK_EQ(request_, request);
   request_ = NULL;
+  net_log_.AddEvent(NetLog::TYPE_HTTP_STREAM_JOB_ORPHANED);
   if (blocking_job_) {
     // We've been orphaned, but there's a job we're blocked on. Don't bother
     // racing, just cancel ourself.
     DCHECK(blocking_job_->waiting_job_);
     blocking_job_->waiting_job_ = NULL;
     blocking_job_ = NULL;
     if (stream_factory_->for_websockets_ &&
         connection_ && connection_->socket()) {
       connection_->socket()->Disconnect();
     }
@@ skipping 419 matching lines @@
     server_ = alternative_service_.host_port_pair();
   } else {
     server_ = HostPortPair::FromURL(request_info_.url);
   }
   origin_url_ =
       stream_factory_->ApplyHostMappingRules(request_info_.url, &server_);
   valid_spdy_session_pool_.reset(new ValidSpdySessionPool(
       session_->spdy_session_pool(), origin_url_, IsSpdyAlternative()));
 
   net_log_.BeginEvent(
       NetLog::TYPE_HTTP_STREAM_JOB,

[mmenke, 2015/06/25 23:23:27]

Should update the docs for this method's parameters.  Looks like the docs don't
currently mention any of them.  :(

[davidben, 2015/06/26 16:35:43]

Done.

-      base::Bind(&NetLogHttpStreamJobCallback, &request_info_.url, &origin_url_,
-                 &alternative_service_, priority_));
+      base::Bind(&NetLogHttpStreamJobCallback,
+                 request_ ? request_->net_log().source() : NetLog::Source(),
+                 &request_info_.url, &origin_url_, &alternative_service_,
+                 priority_));
+  if (request_) {
+    request_->net_log().AddEvent(NetLog::TYPE_HTTP_STREAM_REQUEST_STARTED_JOB,
+                                 net_log_.source().ToEventParametersCallback());
+  }
 
   // Don't connect to restricted ports.
   if (!IsPortAllowedForScheme(server_.port(), request_info_.url.scheme())) {
     if (waiting_job_) {
       waiting_job_->Resume(this);
       waiting_job_ = NULL;
     }
     return ERR_UNSAFE_PORT;
   }
 
@@ skipping 891 matching lines @@
   if (connection_->socket()) {
     ConnectionAttempts socket_attempts;
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
     request_->AddConnectionAttempts(socket_attempts);
   } else {
     request_->AddConnectionAttempts(connection_->connection_attempts());
   }
 }
 
 }  // namespace net