JobController3: Move MarkAlternativeServiceBroken to job controller

net/http/http_stream_factory_impl_job.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_
 #define NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_
 
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 217 matching lines @@
 
   bool is_waiting() const { return next_state_ == STATE_WAIT_COMPLETE; }
   const SSLConfig& server_ssl_config() const;
   const SSLConfig& proxy_ssl_config() const;
   const ProxyInfo& proxy_info() const;
 
   // Called to indicate that this job succeeded, and some other jobs
   // will be orphaned.
   void ReportJobSucceededForRequest();
 
-  // Marks that the other |job| has completed.
-  virtual void MarkOtherJobComplete(const Job& job);
+  JobType job_type() const { return job_type_; }
 
-  JobType job_type() const { return job_type_; }
+  const AlternativeService alternative_service() const {
+    return alternative_service_;
+  }
+
+  const ProxyServer alternative_proxy_server() const {
+    return alternative_proxy_server_;
+  }
 
  private:
   friend class HttpStreamFactoryImplJobPeer;
 
   enum State {
     STATE_START,
     STATE_RESOLVE_PROXY,
     STATE_RESOLVE_PROXY_COMPLETE,
 
     // Note that when Alternate-Protocol says we can connect to an alternate
@@ skipping 22 matching lines @@
     STATE_RESTART_TUNNEL_AUTH,
     STATE_RESTART_TUNNEL_AUTH_COMPLETE,
     STATE_CREATE_STREAM,
     STATE_CREATE_STREAM_COMPLETE,
     STATE_DRAIN_BODY_FOR_AUTH_RESTART,
     STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE,
     STATE_DONE,
     STATE_NONE
   };
 
-  enum JobStatus {
-    STATUS_RUNNING,
-    STATUS_FAILED,
-    STATUS_BROKEN,
-    STATUS_SUCCEEDED
-  };
-
   void OnStreamReadyCallback();
   void OnBidirectionalStreamImplReadyCallback();
   void OnWebSocketHandshakeStreamReadyCallback();
   // This callback function is called when a new SPDY session is created.
   void OnNewSpdySessionReadyCallback();
   void OnStreamFailedCallback(int result);
   void OnCertificateErrorCallback(int result, const SSLInfo& ssl_info);
   void OnNeedsProxyAuthCallback(const HttpResponseInfo& response_info,
                                 HttpAuthController* auth_controller);
   void OnNeedsClientAuthCallback(SSLCertRequestInfo* cert_info);
@@ skipping 72 matching lines @@
 
   // Called to handle a client certificate request.
   int HandleCertificateRequest(int error);
 
   // Moves this stream request into SPDY mode.
   void SwitchToSpdyMode();
 
   // Should we force QUIC for this stream request.
   bool ShouldForceQuic() const;
 
-  void MaybeMarkAlternativeServiceBroken();
-
-  // May notify proxy delegate that the alternative proxy server is broken. The
-  // alternative proxy server is considered as broken if the alternative proxy
-  // server job failed, but the main job was successful.
-  void MaybeNotifyAlternativeProxyServerBroken() const;
-
   ClientSocketPoolManager::SocketGroupType GetSocketGroup() const;
 
   void MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   // Record histograms of latency until Connect() completes.
   static void LogHttpConnectedMetrics(const ClientSocketHandle& handle);
 
   // Invoked by the transport socket pool after host resolution is complete
   // to allow the connection to be aborted, if a matching SPDY session can
   // be found.  Will return ERR_SPDY_SESSION_ALREADY_EXISTS if such a
@@ skipping 22 matching lines @@
   // alternative service (after applying host mapping rules).
   const HostPortPair destination_;
 
   // The origin url we're trying to reach. This url may be different from the
   // original request when host mapping rules are set-up.
   const GURL origin_url_;
 
   // AlternativeService for this Job if this is an alternative Job.
   const AlternativeService alternative_service_;
 
-  // AlternativeService for the other Job if this is not an alternative Job.
-  AlternativeService other_job_alternative_service_;
-
   // Alternative proxy server that should be used by |this| to fetch the
   // request.
   const ProxyServer alternative_proxy_server_;
 
-  // Alternative proxy server for the other job.
-  ProxyServer other_job_alternative_proxy_server_;
-
   // Unowned. |this| job is owned by |delegate_|.
   Delegate* delegate_;
 
   const JobType job_type_;
 
   // True if handling a HTTPS request, or using SPDY with SSL
   bool using_ssl_;
 
   // True if this network transaction is using SPDY instead of HTTP.
   bool using_spdy_;
@@ skipping 34 matching lines @@
 
   // Initialized when we create a new SpdySession.
   base::WeakPtr<SpdySession> new_spdy_session_;
 
   // Initialized when we have an existing SpdySession.
   base::WeakPtr<SpdySession> existing_spdy_session_;
 
   // Only used if |new_spdy_session_| is non-NULL.
   bool spdy_session_direct_;
 
-  JobStatus job_status_;
-  JobStatus other_job_status_;
-
   // Type of stream that is requested.
   HttpStreamRequest::StreamType stream_type_;
 
   base::WeakPtrFactory<Job> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 // Factory for creating Jobs.
 class HttpStreamFactoryImpl::JobFactory {
@@ skipping 38 matching lines @@
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
       NetLog* net_log) = 0;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_