Integrating the QuicStreamFactory into the network stack.

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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_log.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_controller.h"
 #include "net/http/http_pipelined_host.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory_impl.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 
 namespace net {
 
 class ClientSocketHandle;
 class HttpAuthController;
 class HttpNetworkSession;
 class HttpStream;
 class SpdySessionPool;
+class QuicHttpStream;
 
 // An HttpStreamRequestImpl exists for each stream which is in progress of being
 // created for the StreamFactory.
 class HttpStreamFactoryImpl::Job {
  public:
   Job(HttpStreamFactoryImpl* stream_factory,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
@@ skipping 156 matching lines @@
 
   // Moves this stream request into SPDY mode.
   void SwitchToSpdyMode();
 
   // Should we force SPDY to run over SSL for this stream request.
   bool ShouldForceSpdySSL() const;
 
   // Should we force SPDY to run without SSL for this stream request.
   bool ShouldForceSpdyWithoutSSL() const;
 
+  // Should we force QUIC for this stream request.
+  bool ShouldForceQuic() const;
+
   bool IsRequestEligibleForPipelining();
 
   // 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
   // session is found, and OK otherwise.
   static int OnHostResolution(SpdySessionPool* spdy_session_pool,
@@ skipping 36 matching lines @@
   // If |this| is unable to do so, we'll notify |waiting_job_| that it's ok to
   // proceed and then race the two Jobs.
   Job* waiting_job_;
 
   // 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_;
 
+  // True if this network transaction is using QUIC instead of HTTP.
+  bool using_quic_;
+  QuicHttpStream* quic_stream_;
+
   // Force spdy for all connections.
   bool force_spdy_always_;
 
   // Force spdy only for SSL connections.
   bool force_spdy_over_ssl_;
 
+  // Force quic for a specific port.
+  int force_quic_port_;
+
   // The certificate error while using SPDY over SSL for insecure URLs.
   int spdy_certificate_error_;
 
   scoped_refptr<HttpAuthController>
       auth_controllers_[HttpAuth::AUTH_NUM_TARGETS];
 
   // True when the tunnel is in the process of being established - we can't
   // read from the socket until the tunnel is done.
   bool establishing_tunnel_;
 
@@ skipping 25 matching lines @@
   bool existing_available_pipeline_;
 
   base::WeakPtrFactory<Job> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_