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/containers/hash_tables.h" 16 #include "net/base/completion_callback.h" 17 #include "net/quic/quic_connection_logger.h" 18 #include "net/quic/quic_crypto_client_stream.h" 19 #include "net/quic/quic_reliable_client_stream.h" 20 #include "net/quic/quic_session.h" 21 22 namespace net { 23 24 class DatagramClientSocket; 25 class QuicConnectionHelper; 26 class QuicCryptoClientStreamFactory; 27 class QuicStreamFactory; 28 class SSLInfo; 29 30 namespace test { 31 class QuicClientSessionPeer; 32 } // namespace test 33 34 class NET_EXPORT_PRIVATE QuicClientSession : public QuicSession { 35 public: 36 // A helper class used to manage a request to create a stream. 37 class NET_EXPORT_PRIVATE StreamRequest { 38 public: 39 StreamRequest(); 40 ~StreamRequest(); 41 42 // Starts a request to create a stream. If OK is returned, then 43 // |stream| will be updated with the newly created stream. If 44 // ERR_IO_PENDING is returned, then when the request is eventuallly 45 // complete |callback| will be called. 46 int StartRequest(const base::WeakPtr<QuicClientSession> session, 47 QuicReliableClientStream** stream, 48 const CompletionCallback& callback); 49 50 // Cancels any pending stream creation request. May be called 51 // repeatedly. 52 void CancelRequest(); 53 54 private: 55 friend class QuicClientSession; 56 57 // Called by |session_| for an asynchronous request when the stream 58 // request has finished successfully. 59 void OnRequestCompleteSuccess(QuicReliableClientStream* stream); 60 61 // Called by |session_| for an asynchronous request when the stream 62 // request has finished with an error. Also called with ERR_ABORTED 63 // if |session_| is destroyed while the stream request is still pending. 64 void OnRequestCompleteFailure(int rv); 65 66 base::WeakPtr<QuicClientSession> session_; 67 CompletionCallback callback_; 68 QuicReliableClientStream** stream_; 69 70 DISALLOW_COPY_AND_ASSIGN(StreamRequest); 71 }; 72 73 // Constructs a new session which will own |connection| and |helper|, but 74 // not |stream_factory|, which must outlive this session. 75 // TODO(rch): decouple the factory from the session via a Delegate interface. 76 QuicClientSession(QuicConnection* connection, 77 DatagramClientSocket* socket, 78 QuicStreamFactory* stream_factory, 79 QuicCryptoClientStreamFactory* crypto_client_stream_factory, 80 const std::string& server_hostname, 81 const QuicConfig& config, 82 QuicCryptoClientConfig* crypto_config, 83 NetLog* net_log); 84 85 virtual ~QuicClientSession(); 86 87 // Attempts to create a new stream. If the stream can be 88 // created immediately, returns OK. If the open stream limit 89 // has been reached, returns ERR_IO_PENDING, and |request| 90 // will be added to the stream requets queue and will 91 // be completed asynchronously. 92 // TODO(rch): remove |stream| from this and use setter on |request| 93 // and fix in spdy too. 94 int TryCreateStream(StreamRequest* request, 95 QuicReliableClientStream** stream); 96 97 // Cancels the pending stream creation request. 98 void CancelRequest(StreamRequest* request); 99 100 // QuicSession methods: 101 virtual QuicReliableClientStream* CreateOutgoingReliableStream() OVERRIDE; 102 virtual QuicCryptoClientStream* GetCryptoStream() OVERRIDE; 103 virtual void CloseStream(QuicStreamId stream_id) OVERRIDE; 104 virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) OVERRIDE; 105 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE; 106 107 // QuicConnectionVisitorInterface methods: 108 virtual void ConnectionClose(QuicErrorCode error, bool from_peer) OVERRIDE; 109 110 // Performs a crypto handshake with the server. 111 int CryptoConnect(const CompletionCallback& callback); 112 113 // Causes the QuicConnectionHelper to start reading from the socket 114 // and passing the data along to the QuicConnection. 115 void StartReading(); 116 117 // Close the session because of |error| and notifies the factory 118 // that this session has been closed, which will delete the session. 119 void CloseSessionOnError(int error); 120 121 base::Value* GetInfoAsValue(const HostPortPair& pair) const; 122 123 const BoundNetLog& net_log() const { return net_log_; } 124 125 base::WeakPtr<QuicClientSession> GetWeakPtr(); 126 127 protected: 128 // QuicSession methods: 129 virtual ReliableQuicStream* CreateIncomingReliableStream( 130 QuicStreamId id) OVERRIDE; 131 132 private: 133 friend class test::QuicClientSessionPeer; 134 135 typedef std::list<StreamRequest*> StreamRequestQueue; 136 137 QuicReliableClientStream* CreateOutgoingReliableStreamImpl(); 138 // A completion callback invoked when a read completes. 139 void OnReadComplete(int result); 140 141 void CloseSessionOnErrorInner(int error); 142 143 // Posts a task to notify the factory that this session has been closed. 144 void NotifyFactoryOfSessionCloseLater(); 145 146 // Notifies the factory that this session has been closed which will 147 // delete |this|. 148 void NotifyFactoryOfSessionClose(); 149 150 base::WeakPtrFactory<QuicClientSession> weak_factory_; 151 scoped_ptr<QuicCryptoClientStream> crypto_stream_; 152 QuicStreamFactory* stream_factory_; 153 scoped_ptr<DatagramClientSocket> socket_; 154 scoped_refptr<IOBufferWithSize> read_buffer_; 155 StreamRequestQueue stream_requests_; 156 bool read_pending_; 157 CompletionCallback callback_; 158 size_t num_total_streams_; 159 BoundNetLog net_log_; 160 QuicConnectionLogger logger_; 161 162 DISALLOW_COPY_AND_ASSIGN(QuicClientSession); 163 }; 164 165 } // namespace net 166 167 #endif // NET_QUIC_QUIC_CLIENT_SESSION_H_ 168