| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 // | |
| 5 // A client specific QuicSession subclass. This class owns the underlying | |
| 6 // QuicConnection and QuicConnectionHelper objects. The connection stores | |
| 7 // a non-owning pointer to the helper so this session needs to ensure that | |
| 8 // the helper outlives the connection. | |
| 9 | |
| 10 #ifndef NET_QUIC_QUIC_CLIENT_SESSION_H_ | |
| 11 #define NET_QUIC_QUIC_CLIENT_SESSION_H_ | |
| 12 | |
| 13 #include <string> | |
| 14 | |
| 15 #include "base/basictypes.h" | |
| 16 #include "base/containers/hash_tables.h" | |
| 17 #include "base/memory/scoped_ptr.h" | |
| 18 #include "base/time/time.h" | |
| 19 #include "net/base/completion_callback.h" | |
| 20 #include "net/proxy/proxy_server.h" | |
| 21 #include "net/quic/quic_client_session_base.h" | |
| 22 #include "net/quic/quic_connection_logger.h" | |
| 23 #include "net/quic/quic_crypto_client_stream.h" | |
| 24 #include "net/quic/quic_protocol.h" | |
| 25 #include "net/quic/quic_reliable_client_stream.h" | |
| 26 | |
| 27 namespace net { | |
| 28 | |
| 29 class CertVerifyResult; | |
| 30 class DatagramClientSocket; | |
| 31 class QuicConnectionHelper; | |
| 32 class QuicCryptoClientStreamFactory; | |
| 33 class QuicServerId; | |
| 34 class QuicServerInfo; | |
| 35 class QuicStreamFactory; | |
| 36 class SSLInfo; | |
| 37 class TransportSecurityState; | |
| 38 | |
| 39 namespace test { | |
| 40 class QuicClientSessionPeer; | |
| 41 } // namespace test | |
| 42 | |
| 43 class NET_EXPORT_PRIVATE QuicClientSession : public QuicClientSessionBase { | |
| 44 public: | |
| 45 // An interface for observing events on a session. | |
| 46 class NET_EXPORT_PRIVATE Observer { | |
| 47 public: | |
| 48 virtual ~Observer() {} | |
| 49 virtual void OnCryptoHandshakeConfirmed() = 0; | |
| 50 virtual void OnSessionClosed(int error) = 0; | |
| 51 }; | |
| 52 | |
| 53 // A helper class used to manage a request to create a stream. | |
| 54 class NET_EXPORT_PRIVATE StreamRequest { | |
| 55 public: | |
| 56 StreamRequest(); | |
| 57 ~StreamRequest(); | |
| 58 | |
| 59 // Starts a request to create a stream. If OK is returned, then | |
| 60 // |stream| will be updated with the newly created stream. If | |
| 61 // ERR_IO_PENDING is returned, then when the request is eventuallly | |
| 62 // complete |callback| will be called. | |
| 63 int StartRequest(const base::WeakPtr<QuicClientSession>& session, | |
| 64 QuicReliableClientStream** stream, | |
| 65 const CompletionCallback& callback); | |
| 66 | |
| 67 // Cancels any pending stream creation request. May be called | |
| 68 // repeatedly. | |
| 69 void CancelRequest(); | |
| 70 | |
| 71 private: | |
| 72 friend class QuicClientSession; | |
| 73 | |
| 74 // Called by |session_| for an asynchronous request when the stream | |
| 75 // request has finished successfully. | |
| 76 void OnRequestCompleteSuccess(QuicReliableClientStream* stream); | |
| 77 | |
| 78 // Called by |session_| for an asynchronous request when the stream | |
| 79 // request has finished with an error. Also called with ERR_ABORTED | |
| 80 // if |session_| is destroyed while the stream request is still pending. | |
| 81 void OnRequestCompleteFailure(int rv); | |
| 82 | |
| 83 base::WeakPtr<QuicClientSession> session_; | |
| 84 CompletionCallback callback_; | |
| 85 QuicReliableClientStream** stream_; | |
| 86 | |
| 87 DISALLOW_COPY_AND_ASSIGN(StreamRequest); | |
| 88 }; | |
| 89 | |
| 90 // Constructs a new session which will own |connection|, but not | |
| 91 // |stream_factory|, which must outlive this session. | |
| 92 // TODO(rch): decouple the factory from the session via a Delegate interface. | |
| 93 QuicClientSession(QuicConnection* connection, | |
| 94 scoped_ptr<DatagramClientSocket> socket, | |
| 95 QuicStreamFactory* stream_factory, | |
| 96 TransportSecurityState* transport_security_state, | |
| 97 scoped_ptr<QuicServerInfo> server_info, | |
| 98 const QuicConfig& config, | |
| 99 base::TaskRunner* task_runner, | |
| 100 NetLog* net_log); | |
| 101 ~QuicClientSession() override; | |
| 102 | |
| 103 // Initialize session's connection to |server_id|. | |
| 104 void InitializeSession( | |
| 105 const QuicServerId& server_id, | |
| 106 QuicCryptoClientConfig* config, | |
| 107 QuicCryptoClientStreamFactory* crypto_client_stream_factory); | |
| 108 | |
| 109 void AddObserver(Observer* observer); | |
| 110 void RemoveObserver(Observer* observer); | |
| 111 | |
| 112 // Attempts to create a new stream. If the stream can be | |
| 113 // created immediately, returns OK. If the open stream limit | |
| 114 // has been reached, returns ERR_IO_PENDING, and |request| | |
| 115 // will be added to the stream requets queue and will | |
| 116 // be completed asynchronously. | |
| 117 // TODO(rch): remove |stream| from this and use setter on |request| | |
| 118 // and fix in spdy too. | |
| 119 int TryCreateStream(StreamRequest* request, | |
| 120 QuicReliableClientStream** stream); | |
| 121 | |
| 122 // Cancels the pending stream creation request. | |
| 123 void CancelRequest(StreamRequest* request); | |
| 124 | |
| 125 // QuicSession methods: | |
| 126 void OnStreamFrames(const std::vector<QuicStreamFrame>& frames) override; | |
| 127 QuicReliableClientStream* CreateOutgoingDataStream() override; | |
| 128 QuicCryptoClientStream* GetCryptoStream() override; | |
| 129 void CloseStream(QuicStreamId stream_id) override; | |
| 130 void SendRstStream(QuicStreamId id, | |
| 131 QuicRstStreamErrorCode error, | |
| 132 QuicStreamOffset bytes_written) override; | |
| 133 void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override; | |
| 134 void OnCryptoHandshakeMessageSent( | |
| 135 const CryptoHandshakeMessage& message) override; | |
| 136 void OnCryptoHandshakeMessageReceived( | |
| 137 const CryptoHandshakeMessage& message) override; | |
| 138 bool GetSSLInfo(SSLInfo* ssl_info) const override; | |
| 139 | |
| 140 // QuicClientSessionBase methods: | |
| 141 void OnProofValid(const QuicCryptoClientConfig::CachedState& cached) override; | |
| 142 void OnProofVerifyDetailsAvailable( | |
| 143 const ProofVerifyDetails& verify_details) override; | |
| 144 | |
| 145 // QuicConnectionVisitorInterface methods: | |
| 146 void OnConnectionClosed(QuicErrorCode error, bool from_peer) override; | |
| 147 void OnSuccessfulVersionNegotiation(const QuicVersion& version) override; | |
| 148 | |
| 149 // Performs a crypto handshake with the server. | |
| 150 int CryptoConnect(bool require_confirmation, | |
| 151 const CompletionCallback& callback); | |
| 152 | |
| 153 // Resumes a crypto handshake with the server after a timeout. | |
| 154 int ResumeCryptoConnect(const CompletionCallback& callback); | |
| 155 | |
| 156 // Causes the QuicConnectionHelper to start reading from the socket | |
| 157 // and passing the data along to the QuicConnection. | |
| 158 void StartReading(); | |
| 159 | |
| 160 // Close the session because of |error| and notifies the factory | |
| 161 // that this session has been closed, which will delete the session. | |
| 162 void CloseSessionOnError(int error); | |
| 163 | |
| 164 base::Value* GetInfoAsValue(const std::set<HostPortPair>& aliases); | |
| 165 | |
| 166 const BoundNetLog& net_log() const { return net_log_; } | |
| 167 | |
| 168 base::WeakPtr<QuicClientSession> GetWeakPtr(); | |
| 169 | |
| 170 // Returns the number of client hello messages that have been sent on the | |
| 171 // crypto stream. If the handshake has completed then this is one greater | |
| 172 // than the number of round-trips needed for the handshake. | |
| 173 int GetNumSentClientHellos() const; | |
| 174 | |
| 175 // Returns true if |hostname| may be pooled onto this session. If this | |
| 176 // is a secure QUIC session, then |hostname| must match the certificate | |
| 177 // presented during the handshake. | |
| 178 bool CanPool(const std::string& hostname, PrivacyMode privacy_mode) const; | |
| 179 | |
| 180 const QuicServerId& server_id() const { return server_id_; } | |
| 181 | |
| 182 protected: | |
| 183 // QuicSession methods: | |
| 184 QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override; | |
| 185 | |
| 186 private: | |
| 187 friend class test::QuicClientSessionPeer; | |
| 188 | |
| 189 typedef std::set<Observer*> ObserverSet; | |
| 190 typedef std::list<StreamRequest*> StreamRequestQueue; | |
| 191 | |
| 192 QuicReliableClientStream* CreateOutgoingReliableStreamImpl(); | |
| 193 // A completion callback invoked when a read completes. | |
| 194 void OnReadComplete(int result); | |
| 195 | |
| 196 void OnClosedStream(); | |
| 197 | |
| 198 // A Session may be closed via any of three methods: | |
| 199 // OnConnectionClosed - called by the connection when the connection has been | |
| 200 // closed, perhaps due to a timeout or a protocol error. | |
| 201 // CloseSessionOnError - called from the owner of the session, | |
| 202 // the QuicStreamFactory, when there is an error. | |
| 203 // OnReadComplete - when there is a read error. | |
| 204 // This method closes all stream and performs any necessary cleanup. | |
| 205 void CloseSessionOnErrorInner(int net_error, QuicErrorCode quic_error); | |
| 206 | |
| 207 void CloseAllStreams(int net_error); | |
| 208 void CloseAllObservers(int net_error); | |
| 209 | |
| 210 // Notifies the factory that this session is going away and no more streams | |
| 211 // should be created from it. This needs to be called before closing any | |
| 212 // streams, because closing a stream may cause a new stream to be created. | |
| 213 void NotifyFactoryOfSessionGoingAway(); | |
| 214 | |
| 215 // Posts a task to notify the factory that this session has been closed. | |
| 216 void NotifyFactoryOfSessionClosedLater(); | |
| 217 | |
| 218 // Notifies the factory that this session has been closed which will | |
| 219 // delete |this|. | |
| 220 void NotifyFactoryOfSessionClosed(); | |
| 221 | |
| 222 void OnConnectTimeout(); | |
| 223 | |
| 224 QuicServerId server_id_; | |
| 225 bool require_confirmation_; | |
| 226 scoped_ptr<QuicCryptoClientStream> crypto_stream_; | |
| 227 QuicStreamFactory* stream_factory_; | |
| 228 scoped_ptr<DatagramClientSocket> socket_; | |
| 229 scoped_refptr<IOBufferWithSize> read_buffer_; | |
| 230 TransportSecurityState* transport_security_state_; | |
| 231 scoped_ptr<QuicServerInfo> server_info_; | |
| 232 scoped_ptr<CertVerifyResult> cert_verify_result_; | |
| 233 std::string pinning_failure_log_; | |
| 234 ObserverSet observers_; | |
| 235 StreamRequestQueue stream_requests_; | |
| 236 bool read_pending_; | |
| 237 CompletionCallback callback_; | |
| 238 size_t num_total_streams_; | |
| 239 base::TaskRunner* task_runner_; | |
| 240 BoundNetLog net_log_; | |
| 241 base::TimeTicks handshake_start_; // Time the handshake was started. | |
| 242 QuicConnectionLogger* logger_; // Owned by |connection_|. | |
| 243 // Number of packets read in the current read loop. | |
| 244 size_t num_packets_read_; | |
| 245 // True when the session is going away, and streams may no longer be created | |
| 246 // on this session. Existing stream will continue to be processed. | |
| 247 bool going_away_; | |
| 248 base::WeakPtrFactory<QuicClientSession> weak_factory_; | |
| 249 | |
| 250 DISALLOW_COPY_AND_ASSIGN(QuicClientSession); | |
| 251 }; | |
| 252 | |
| 253 } // namespace net | |
| 254 | |
| 255 #endif // NET_QUIC_QUIC_CLIENT_SESSION_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master