JobController 2: Remove reference between HttpStreamFactoryImpl::Jobs.

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 "net/http/bidirectional_stream_impl.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 HttpStreamFactoryImpl::JobController::JobController(
     HttpStreamFactoryImpl* factory)
     : factory_(factory),
       request_(NULL),
       main_job_(NULL),
-      alternative_job_(NULL) {
+      alternative_job_(NULL),
+      racing_(false) {
   DCHECK(factory);
 }
 
 HttpStreamFactoryImpl::JobController::~JobController() {
+  DCHECK(jobs_.empty());
+  DCHECK(!bound_job_.get());
   std::set<const Job*> tmp_job_set;
   tmp_job_set.swap(orphaned_job_set_);
   STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end());
   DCHECK(orphaned_job_set_.empty());
 }
 
 HttpStreamFactoryImpl::Request*
 HttpStreamFactoryImpl::JobController::CreatRequest(
     const HttpRequestInfo& request_info,
     HttpStreamRequest::Delegate* delegate,
@@ skipping 18 matching lines @@
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     HttpStreamRequest::StreamType stream_type,
     const BoundNetLog& net_log) {
   DCHECK(!main_job_);
   DCHECK(!alternative_job_);
   HostPortPair destination(HostPortPair::FromURL(request_info.url));
   GURL origin_url =
       factory_->ApplyHostMappingRules(request_info.url, &destination);
 
-  main_job_ =
-      new Job(this, session, request_info, priority, server_ssl_config,
-              proxy_ssl_config, destination, origin_url, net_log.net_log());
+  main_job_ = new Job(this, NON_ALTERNATIVE, session, request_info, priority,
+                      server_ssl_config, proxy_ssl_config, destination,
+                      origin_url, net_log.net_log());
   jobs_.insert(main_job_);
   AttachJob(main_job_);
 
   // Create an alternative job if alternative service is set up for this domain.
   const AlternativeService alternative_service =
       factory_->GetAlternativeServiceFor(request_info, delegate, stream_type);
 
   if (alternative_service.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
     // Never share connection with other jobs for FTP requests.
     DVLOG(1) << "Selected alternative service (host: "
              << alternative_service.host_port_pair().host()
              << " port: " << alternative_service.host_port_pair().port() << ")";
 
     DCHECK(!request_info.url.SchemeIs("ftp"));
     HostPortPair alternative_destination(alternative_service.host_port_pair());
     ignore_result(factory_->ApplyHostMappingRules(request_info.url,
                                                   &alternative_destination));
 
     alternative_job_ =
-        new Job(this, session, request_info, priority, server_ssl_config,
-                proxy_ssl_config, alternative_destination, origin_url,
-                alternative_service, net_log.net_log());
+        new Job(this, ALTERNATIVE, session, request_info, priority,
+                server_ssl_config, proxy_ssl_config, alternative_destination,
+                origin_url, alternative_service, net_log.net_log());
     jobs_.insert(alternative_job_);
     AttachJob(alternative_job_);
-
-    main_job_->WaitFor(alternative_job_);
-    // Make sure to wait until we call WaitFor(), before starting
-    // |alternative_job|, otherwise |alternative_job| will not notify |job|
-    // appropriately.
+    racing_ = true;
     alternative_job_->Start(request_);
   }
   // Even if |alternative_job| has already finished, it will not have notified
   // the request yet, since we defer that to the next iteration of the
   // MessageLoop, so starting |job| is always safe.
   main_job_->Start(request_);
 }
 
 void HttpStreamFactoryImpl::JobController::Preconnect(
     int num_streams,
@@ skipping 22 matching lines @@
     }
     destination = alternative_service.host_port_pair();
     ignore_result(
         factory_->ApplyHostMappingRules(request_info.url, &destination));
   }
 
   // Due to how the socket pools handle priorities and idle sockets, only IDLE
   // priority currently makes sense for preconnects. The priority for
   // preconnects is currently ignored (see RequestSocketsForPool()), but could
   // be used at some point for proxy resolution or something.
-  main_job_ = new Job(this, session, request_info, IDLE, server_ssl_config,
-                      proxy_ssl_config, destination, origin_url,
-                      alternative_service, session->net_log());
+  main_job_ = new Job(this, PRECONNECT, session, request_info, IDLE,
+                      server_ssl_config, proxy_ssl_config, destination,
+                      origin_url, alternative_service, session->net_log());
   jobs_.insert(main_job_);
   main_job_->Preconnect(num_streams);
 }
 
 LoadState HttpStreamFactoryImpl::JobController::GetLoadState() const {
   DCHECK(request_);
   if (bound_job_.get())
     return bound_job_->GetLoadState();
   DCHECK(!jobs_.empty());
 
@@ skipping 184 matching lines @@
     return;
   DCHECK_NE(OK, status);
   DCHECK(job);
 
   if (!bound_job_.get()) {
     if (jobs_.size() > 1) {
       // Hey, we've got other jobs! Maybe one of them will succeed, let's just
       // ignore this failure.
       jobs_.erase(job);
       factory_->request_map_.erase(job);
+      DCHECK_EQ(jobs_.size(), 1u);
       // Notify all the other jobs that this one failed.
       for (std::set<Job*>::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
         (*it)->MarkOtherJobComplete(*job);
       delete job;
       return;
     } else {
       BindJob(job);
     }
   } else {
     DCHECK(jobs_.empty());
@@ skipping 119 matching lines @@
   MaybeNotifyFactoryOfCompletion();
 }
 
 void HttpStreamFactoryImpl::JobController::OnOrphanedJobComplete(
     const Job* job) {
   orphaned_job_set_.erase(job);
   delete job;
   MaybeNotifyFactoryOfCompletion();
 }
 
+void HttpStreamFactoryImpl::JobController::OnJobDeletion(Job* job) {
+  DCHECK(!ContainsKey(jobs_, job));
+  DCHECK(job);
+  if (job == main_job_) {
+    main_job_ = NULL;

[Ryan Hamilton, 2016/05/06 21:33:14]

nullptr is cool now, NULL is *so* 2015 :>

[Zhongyi Shi, 2016/05/13 00:31:25]

Acknowledged.

+  } else if (job == alternative_job_) {
+    alternative_job_ = NULL;
+  } else {
+    NOTREACHED();
+  }
+}
+
 void HttpStreamFactoryImpl::JobController::AddConnectionAttemptsToRequest(
     const ConnectionAttempts& attempts) {
   DCHECK(request_);
   request_->AddConnectionAttempts(attempts);
 }
 
 void HttpStreamFactoryImpl::JobController::SetSpdySessionKey(
     const SpdySessionKey& spdy_session_key) {
   DCHECK(request_);
   if (!request_->HasSpdySessionKey()) {
     request_->SetSpdySessionKey(spdy_session_key);
   }
 }
 
 void HttpStreamFactoryImpl::JobController::
     RemoveRequestFromSpdySessionRequestMap() {
   DCHECK(request_);
   request_->RemoveRequestFromSpdySessionRequestMap();
 }
 
 void HttpStreamFactoryImpl::JobController::MaybeNotifyFactoryOfCompletion() {
   if (!request_ && jobs_.empty() && orphaned_job_set_.empty()) {
     DCHECK(jobs_.empty());
     factory_->OnJobControllerComplete(this);
   }
 }
 
+void HttpStreamFactoryImpl::JobController::MaybeResumeOtherJob(
+    Job* job,
+    const base::TimeDelta& delay) {
+  if (!racing_)
+    return;
+
+  if (job == alternative_job_ && main_job_) {
+    main_job_->Resume(delay);
+  } else if (job != main_job_ && job != alternative_job_) {
+    NOTREACHED();
+  }
+  racing_ = false;
+}
+
 const BoundNetLog& HttpStreamFactoryImpl::JobController::GetNetLogFromRequest()
     const {
   DCHECK(request_);
   return request_->net_log();
 }
 
 WebSocketHandshakeStreamBase::CreateHelper* HttpStreamFactoryImpl::
     JobController::websocket_handshake_stream_create_helper() {
   DCHECK(request_);
   return request_->websocket_handshake_stream_create_helper();
 }
 }