JobController 2: Remove reference between HttpStreamFactoryImpl::Jobs.

net/http/http_stream_factory_impl_job_controller.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_
 #define NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_
 
 #include "net/http/http_stream_factory_impl.h"
 
 namespace net {
@@ skipping 99 matching lines @@
       std::unique_ptr<BidirectionalStreamImpl> bidirectional_stream_impl,
       const base::WeakPtr<SpdySession>& spdy_session,
       bool direct);
 
   // Invoked when the Job finishes pre-connecting sockets.
   void OnPreconnectsComplete(Job* job);
 
   // Invoked when an orphaned Job finishes.
   void OnOrphanedJobComplete(const Job* job);
 
+  // Removes cached reference to |job|.
+  void OnJobDeletion(Job* job);
+
   // Called by an attached Job to record connection attempts made by the socket
   // layer to |request_|.
   void AddConnectionAttemptsToRequest(const ConnectionAttempts& attempts);
 
   // Called when Job determines the appropriate |spdy_session_key| for the
   // Request. Note that this does not mean that SPDY is necessarily supported
   // for this SpdySessionKey, since we may need to wait for NPN to complete
   // before knowing if SPDY is available.
   void SetSpdySessionKey(const SpdySessionKey& spdy_session_key);
 
   // Remove session from the SpdySessionRequestMap.
   void RemoveRequestFromSpdySessionRequestMap();
 
   void MaybeNotifyFactoryOfCompletion();
 
+  void MaybeResumeOtherJob(Job* job, const base::TimeDelta& delay);
+
   const BoundNetLog& GetNetLogFromRequest() const;
 
   SpdySessionRequestMap& GetSpdySessionRequestMap() {
     return factory_->spdy_session_request_map_;
   }
 
   bool for_websockets() { return factory_->for_websockets_; }
 
+  bool racing() { return racing_; }
+
   WebSocketHandshakeStreamBase::CreateHelper*
   websocket_handshake_stream_create_helper();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, SetPriority);
   FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, DelayMainJob);
 
   // Creates Job(s) for |request_|. Jobs will be owned by |this|.
   void CreateJobs();
 
   // Attaches |job| to |request_|. Does not mean that |request_| will use |job|.
   void AttachJob(Job* job);
 
   HttpStreamFactoryImpl* factory_;
 
   // Request will be handed out to factory once created. This just keeps an
   // reference. It will be set to NULL once the request is completed.
   Request* request_;
 
   std::set<Job*> jobs_;
 
   // |main_job_| is a job waiting to see if |alternative_job_| can reuse a
   // connection. If |alternative_job_| is unable to do so, |this| will notify
   // |main_job_| to proceed and then race the two jobs.
   Job* main_job_;
   Job* alternative_job_;
 
+  // True if the |main_job_| has to wait for |alternative_job_|;
+  bool racing_;

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

If this is about the alt job blocking the main job, it seems like blocking_
would be a better name than racing_.

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

Done.

+
   // At the point where a Job is irrevocably tied to |request_|, we set this.
   std::unique_ptr<Job> bound_job_;
 
   // These jobs correspond to jobs orphaned by |request_|. Since they are no
   // longer tied to Requests, they will not be canceled when |request_| is
   // canceled. Therefore, in ~JobController, it is possible for some jobs to
   // still exist in this set. Leftover jobs will be deleted when the
   // JobController is destroyed.
   std::set<const Job*> orphaned_job_set_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_