[DO NOT SUBMIT, PATCH on commit 7fa349e632a44c152b05ca6a66ade5f2e5b3f139]

net/http/http_stream_factory_impl_job_controller.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 <string>
 #include <utility>
 
@@ skipping 56 matching lines @@
                                  NetLogSourceType::HTTP_STREAM_JOB_CONTROLLER)),
       ptr_factory_(this) {
   DCHECK(factory);
   net_log_.BeginEvent(NetLogEventType::HTTP_STREAM_JOB_CONTROLLER,
                       base::Bind(&NetLogJobControllerCallback,
                                  &request_info.url, is_preconnect));
 }
 
 HttpStreamFactoryImpl::JobController::~JobController() {
   main_job_.reset();
+  if (alternative_job_.get()) {
+    alternative_job_->net_log().AddEvent(
+        NetLogEventType::ALT_JOB_DELETED_ON_DESTRUCT_JOB_CONTROLLER);
+  }
   alternative_job_.reset();
   bound_job_ = nullptr;
   net_log_.EndEvent(NetLogEventType::HTTP_STREAM_JOB_CONTROLLER);
 }
 
 bool HttpStreamFactoryImpl::JobController::for_websockets() {
   return factory_->for_websockets_;
 }
 
 HttpStreamFactoryImpl::Request* HttpStreamFactoryImpl::JobController::Start(
@@ skipping 83 matching lines @@
   request_ = nullptr;
   if (bound_job_) {
     if (bound_job_->job_type() == MAIN) {
       main_job_.reset();
       // |alternative_job_| can be non-null if |main_job_| is resumed after
       // |main_job_wait_time_| has elapsed. Allow |alternative_job_| to run to
       // completion, rather than resetting it. OnOrphanedJobComplete() will
       // clean up |this| when the job completes.
     } else {
       DCHECK(bound_job_->job_type() == ALTERNATIVE);
+      if (alternative_job_) {
+        alternative_job_->net_log().AddEvent(
+            NetLogEventType::ALT_JOB_DELETED_ON_REQUEST_COMPLETE_AND_BOUND);
+      }
       alternative_job_.reset();
     }
     bound_job_ = nullptr;
   }
   MaybeNotifyFactoryOfCompletion();
 }
 
 int HttpStreamFactoryImpl::JobController::RestartTunnelWithProxyAuth() {
   DCHECK(bound_job_);
   return bound_job_->RestartTunnelWithProxyAuth();
 }
 
 void HttpStreamFactoryImpl::JobController::SetPriority(
     RequestPriority priority) {
   if (main_job_) {
     main_job_->SetPriority(priority);
   }
   if (alternative_job_) {
     alternative_job_->SetPriority(priority);
   }
 }
 
 void HttpStreamFactoryImpl::JobController::OnStreamReady(
     Job* job,
     const SSLConfig& used_ssl_config) {
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_STREAM_READY,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
   DCHECK(job);
 
   factory_->OnStreamReady(job->proxy_info(), privacy_mode_);
 
   if (IsJobOrphaned(job)) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
   std::unique_ptr<HttpStream> stream = job->ReleaseStream();
   DCHECK(stream);
 
   MarkRequestComplete(job->was_alpn_negotiated(), job->negotiated_protocol(),
                       job->using_spdy());
 
   if (!request_)
     return;
   DCHECK(!factory_->for_websockets_);
   DCHECK_EQ(HttpStreamRequest::HTTP_STREAM, request_->stream_type());
   OnJobSucceeded(job);
   request_->OnStreamReady(used_ssl_config, job->proxy_info(), stream.release());
 }
 
 void HttpStreamFactoryImpl::JobController::OnBidirectionalStreamImplReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info) {
   DCHECK(job);
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_BI_STREAN_IMPL_READY,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
 
   if (IsJobOrphaned(job)) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
 
   MarkRequestComplete(job->was_alpn_negotiated(), job->negotiated_protocol(),
                       job->using_spdy());
 
@@ skipping 27 matching lines @@
 
   OnJobSucceeded(job);
   request_->OnWebSocketHandshakeStreamReady(used_ssl_config, used_proxy_info,
                                             stream);
 }
 
 void HttpStreamFactoryImpl::JobController::OnStreamFailed(
     Job* job,
     int status,
     const SSLConfig& used_ssl_config) {
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_STREAM_FAILED,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
   if (job->job_type() == ALTERNATIVE) {
     DCHECK_EQ(alternative_job_.get(), job);
     OnAlternativeJobFailed(status);
   }
 
   MaybeResumeMainJob(job, base::TimeDelta());
 
   if (IsJobOrphaned(job)) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
 
-  if (!request_)
+  if (!request_) {
     return;
+  }
   DCHECK_NE(OK, status);
   DCHECK(job);
 
   if (!bound_job_) {
     if (main_job_ && alternative_job_) {
       // Hey, we've got other jobs! Maybe one of them will succeed, let's just
       // ignore this failure.
       factory_->request_map_.erase(job);
       if (job->job_type() == MAIN) {
         main_job_.reset();
       } else {
         DCHECK(job->job_type() == ALTERNATIVE);
+        job->net_log().AddEvent(
+            NetLogEventType::ALT_JOB_DELETED_ON_STREAM_FAILED);
         alternative_job_.reset();
       }
       return;
     } else {
       BindJob(job);
     }
   }
 
   request_->OnStreamFailed(status, used_ssl_config);
 }
 
 void HttpStreamFactoryImpl::JobController::OnCertificateError(
     Job* job,
     int status,
     const SSLConfig& used_ssl_config,
     const SSLInfo& ssl_info) {
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_CERTIFICATE_ERROR,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
   MaybeResumeMainJob(job, base::TimeDelta());
 
   if (IsJobOrphaned(job)) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
 
   if (!request_)
     return;
   DCHECK_NE(OK, status);
   if (!bound_job_)
     BindJob(job);
 
   request_->OnCertificateError(status, used_ssl_config, ssl_info);
 }
 
 void HttpStreamFactoryImpl::JobController::OnHttpsProxyTunnelResponse(
     Job* job,
     const HttpResponseInfo& response_info,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     HttpStream* stream) {
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_HTTPS_PROXY_TUNNEL_REPONSE,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
   MaybeResumeMainJob(job, base::TimeDelta());
 
   if (IsJobOrphaned(job)) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
 
   if (!bound_job_)
     BindJob(job);
   if (!request_)
     return;
   request_->OnHttpsProxyTunnelResponse(response_info, used_ssl_config,
                                        used_proxy_info, stream);
 }
 
 void HttpStreamFactoryImpl::JobController::OnNeedsClientAuth(
     Job* job,
     const SSLConfig& used_ssl_config,
     SSLCertRequestInfo* cert_info) {
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_NEEDS_CLIENT_AUTH,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
+
   MaybeResumeMainJob(job, base::TimeDelta());
 
   if (IsJobOrphaned(job)) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
   if (!request_)
     return;
   if (!bound_job_)
     BindJob(job);
 
   request_->OnNeedsClientAuth(used_ssl_config, cert_info);
 }
 
 void HttpStreamFactoryImpl::JobController::OnNeedsProxyAuth(
     Job* job,
     const HttpResponseInfo& proxy_response,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     HttpAuthController* auth_controller) {
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_NEEDS_PROXY_AUTH,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
+
   MaybeResumeMainJob(job, base::TimeDelta());
 
   if (IsJobOrphaned(job)) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
 
   if (!request_)
     return;
@@ skipping 46 matching lines @@
       base::Bind(
           &HttpStreamFactoryImpl::JobController::StartAlternativeProxyServerJob,
           ptr_factory_.GetWeakPtr()));
 }
 
 void HttpStreamFactoryImpl::JobController::OnNewSpdySessionReady(
     Job* job,
     const base::WeakPtr<SpdySession>& spdy_session,
     bool direct) {
   DCHECK(job);
+
+  job->net_log().AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_ON_NEW_SPDY_SESSION_READY,
+      NetLog::BoolCallback("is_orphaned", IsJobOrphaned(job)));
   DCHECK(job->using_spdy());
   DCHECK(!is_preconnect_);
 
   bool is_job_orphaned = IsJobOrphaned(job);
 
   // Cache these values in case the job gets deleted.
   const SSLConfig used_ssl_config = job->server_ssl_config();
   const ProxyInfo used_proxy_info = job->proxy_info();
   const bool was_alpn_negotiated = job->was_alpn_negotiated();
   const NextProto negotiated_protocol = job->negotiated_protocol();
@@ skipping 55 matching lines @@
   MaybeNotifyFactoryOfCompletion();
 }
 
 void HttpStreamFactoryImpl::JobController::OnOrphanedJobComplete(
     const Job* job) {
   if (job->job_type() == MAIN) {
     DCHECK_EQ(main_job_.get(), job);
     main_job_.reset();
   } else {
     DCHECK_EQ(alternative_job_.get(), job);
+    job->net_log().AddEvent(
+        NetLogEventType::ALT_JOB_DELETED_IN_ON_ORPHANED_JOB_COMPLETE);
     alternative_job_.reset();
   }
 
   MaybeNotifyFactoryOfCompletion();
 }
 
 void HttpStreamFactoryImpl::JobController::AddConnectionAttemptsToRequest(
     Job* job,
     const ConnectionAttempts& attempts) {
   if (is_preconnect_ || (job_bound_ && bound_job_ != job))
@@ skipping 119 matching lines @@
 
 const NetLogWithSource* HttpStreamFactoryImpl::JobController::GetNetLog(
     Job* job) const {
   return &net_log_;
 }
 
 void HttpStreamFactoryImpl::JobController::MaybeSetWaitTimeForMainJob(
     const base::TimeDelta& delay) {
   if (main_job_is_blocked_) {
     main_job_wait_time_ = std::min(
-        delay, base::TimeDelta::FromSeconds(kMaxDelayTimeForMainJobSecs));
+        delay, base::TimeDelta::FromMilliseconds(kMaxDelayTimeForMainJobSecs));
   }
 }
 
 bool HttpStreamFactoryImpl::JobController::HasPendingMainJob() const {
   return main_job_.get() != nullptr;
 }
 
 bool HttpStreamFactoryImpl::JobController::HasPendingAltJob() const {
   return alternative_job_.get() != nullptr;
 }
@@ skipping 88 matching lines @@
   OrphanUnboundJob();
 }
 
 void HttpStreamFactoryImpl::JobController::CancelJobs() {
   DCHECK(request_);
   RemoveRequestFromSpdySessionRequestMap();
   if (job_bound_)
     return;
   if (alternative_job_) {
     factory_->request_map_.erase(alternative_job_.get());
+    if (alternative_job_) {
+      alternative_job_->net_log().AddEvent(
+          NetLogEventType::ALT_JOB_DELETED_ON_CANCEL_JOBS);
+    }
     alternative_job_.reset();
   }
   if (main_job_) {
     factory_->request_map_.erase(main_job_.get());
     main_job_.reset();
   }
 }
 
 void HttpStreamFactoryImpl::JobController::OrphanUnboundJob() {
   DCHECK(request_);
@@ skipping 382 matching lines @@
     return;
   DCHECK(alternative_job_->alternative_proxy_server().is_valid());
   alternative_job_->Start(request_->stream_type());
 }
 
 bool HttpStreamFactoryImpl::JobController::IsJobOrphaned(Job* job) const {
   return !request_ || (job_bound_ && bound_job_ != job);
 }
 
 }  // namespace net