Extract Proxy Resolution out of HttpStreamFactoryImpl::Job

net/quic/chromium/quic_stream_factory.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_QUIC_CHROMIUM_QUIC_STREAM_FACTORY_H_
 #define NET_QUIC_CHROMIUM_QUIC_STREAM_FACTORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 90 matching lines @@
   MIGRATION_STATUS_DISABLED,
   MIGRATION_STATUS_NO_ALTERNATE_NETWORK,
   MIGRATION_STATUS_MAX
 };
 
 // Encapsulates a pending request for a QuicHttpStream.
 // If the request is still pending when it is destroyed, it will
 // cancel the request with the factory.
 class NET_EXPORT_PRIVATE QuicStreamRequest {
  public:
-  explicit QuicStreamRequest(QuicStreamFactory* factory,
-                             HttpServerProperties* http_server_properties);
+  QuicStreamRequest(QuicStreamFactory* factory,
+                    HttpServerProperties* http_server_properties);
   ~QuicStreamRequest();
 
   // |cert_verify_flags| is bitwise OR'd of CertVerifier::VerifyFlags and it is
   // passed to CertVerifier::Verify.
   // |destination| will be resolved and resulting IPEndPoint used to open a
   // QuicConnection.  This can be different than HostPortPair::FromURL(url).
-  int Request(const HostPortPair& destination,
-              PrivacyMode privacy_mode,
-              int cert_verify_flags,
-              const GURL& url,
-              QuicStringPiece method,
-              const NetLogWithSource& net_log,
-              const CompletionCallback& callback);
+  virtual int Request(const HostPortPair& destination,
+                      PrivacyMode privacy_mode,
+                      int cert_verify_flags,
+                      const GURL& url,
+                      QuicStringPiece method,
+                      const NetLogWithSource& net_log,
+                      const CompletionCallback& callback);
 
   void OnRequestComplete(int rv);
 
   // Helper method that calls |factory_|'s GetTimeDelayForWaitingJob(). It
   // returns the amount of time waiting job should be delayed.
   base::TimeDelta GetTimeDelayForWaitingJob() const;
 
-  std::unique_ptr<QuicHttpStream> CreateStream();
+  virtual std::unique_ptr<HttpStream> CreateStream();
 
-  std::unique_ptr<BidirectionalStreamImpl> CreateBidirectionalStreamImpl();
+  virtual std::unique_ptr<BidirectionalStreamImpl>
+  CreateBidirectionalStreamImpl();
 
   // Sets |session_|.
   void SetSession(QuicChromiumClientSession* session);
 
   const QuicServerId& server_id() const { return server_id_; }
 
   const NetLogWithSource& net_log() const { return net_log_; }
 
  private:
   QuicStreamFactory* factory_;
   HttpServerProperties* http_server_properties_;
   QuicServerId server_id_;
   NetLogWithSource net_log_;
   CompletionCallback callback_;
   base::WeakPtr<QuicChromiumClientSession> session_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamRequest);
 };
 
+// A default factory for creating QuicStreamRequest. Subclassed for testing
+// purpose.
+class NET_EXPORT_PRIVATE QuicStreamRequestFactory {
+ public:
+  QuicStreamRequestFactory();
+  ~QuicStreamRequestFactory();
+
+  virtual std::unique_ptr<QuicStreamRequest> CreateRequest(
+      QuicStreamFactory* factory,
+      HttpServerProperties* http_server_properties);
+};
+
 // A factory for creating new QuicHttpStreams on top of a pool of
 // QuicChromiumClientSessions.
 class NET_EXPORT_PRIVATE QuicStreamFactory
     : public NetworkChangeNotifier::IPAddressObserver,
       public NetworkChangeNotifier::NetworkObserver,
       public SSLConfigService::Observer,
       public CertDatabase::Observer {
  public:
   // This class encompasses |destination| and |server_id|.
   // |destination| is a HostPortPair which is resolved
@@ skipping 58 matching lines @@
       const QuicTagVector& connection_options,
       bool enable_token_binding);
   ~QuicStreamFactory() override;
 
   // Returns true if there is an existing session for |server_id| or if the
   // request can be pooled to an existing session to the IP address of
   // |destination|.
   bool CanUseExistingSession(const QuicServerId& server_id,
                              const HostPortPair& destination);
 
+  std::unique_ptr<QuicStreamRequest> CreateStreamRequest();
+
   // Creates a new QuicHttpStream to |host_port_pair| which will be
   // owned by |request|.
   // If a matching session already exists, this method will return OK.  If no
   // matching session exists, this will return ERR_IO_PENDING and will invoke
   // OnRequestComplete asynchronously.
   int Create(const QuicServerId& server_id,
              const HostPortPair& destination,
              int cert_verify_flags,
              const GURL& url,
              QuicStringPiece method,
@@ skipping 243 matching lines @@
   // is created for every QUIC connection.
   // |socket_performance_watcher_factory_| may be null.
   SocketPerformanceWatcherFactory* socket_performance_watcher_factory_;
 
   // The helper used for all connections.
   std::unique_ptr<QuicChromiumConnectionHelper> helper_;
 
   // The alarm factory used for all connections.
   std::unique_ptr<QuicAlarmFactory> alarm_factory_;
 
+  std::unique_ptr<QuicStreamRequestFactory> stream_request_factory_;
+
   // Contains owning pointers to all sessions that currently exist.
   SessionIdMap all_sessions_;
   // Contains non-owning pointers to currently active session
   // (not going away session, once they're implemented).
   SessionMap active_sessions_;
   // Map from session to set of aliases that this session is known by.
   SessionAliasMap session_aliases_;
   // Map from IP address to sessions which are connected to this address.
   IPAliasMap ip_aliases_;
   // Map from session to its original peer IP address.
@@ skipping 73 matching lines @@
   const scoped_refptr<SSLConfigService> ssl_config_service_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_STREAM_FACTORY_H_