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 server specific QuicSession subclass. 6 7#ifndef NET_TOOLS_QUIC_QUIC_SERVER_SESSION_H_ 8#define NET_TOOLS_QUIC_QUIC_SERVER_SESSION_H_ 9 10#include <set> 11#include <vector> 12 13#include "base/basictypes.h" 14#include "base/containers/hash_tables.h" 15#include "base/memory/scoped_ptr.h" 16#include "net/quic/quic_crypto_server_stream.h" 17#include "net/quic/quic_protocol.h" 18#include "net/quic/quic_session.h" 19 20namespace net { 21 22class QuicBlockedWriterInterface; 23class QuicConfig; 24class QuicConnection; 25class QuicCryptoServerConfig; 26class ReliableQuicStream; 27 28namespace tools { 29 30namespace test { 31class QuicServerSessionPeer; 32} // namespace test 33 34// An interface from the session to the entity owning the session. 35// This lets the session notify its owner (the Dispatcher) when the connection 36// is closed or blocked. 37class QuicServerSessionVisitor { 38 public: 39 virtual ~QuicServerSessionVisitor() {} 40 41 virtual void OnConnectionClosed(QuicConnectionId connection_id, 42 QuicErrorCode error) = 0; 43 virtual void OnWriteBlocked(QuicBlockedWriterInterface* blocked_writer) = 0; 44}; 45 46class QuicServerSession : public QuicSession { 47 public: 48 QuicServerSession(const QuicConfig& config, 49 QuicConnection* connection, 50 QuicServerSessionVisitor* visitor); 51 52 // Override the base class to notify the owner of the connection close. 53 virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE; 54 virtual void OnWriteBlocked() OVERRIDE; 55 56 // Sends a server config update to the client, containing new bandwidth 57 // estimate. 58 virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE; 59 60 virtual ~QuicServerSession(); 61 62 virtual void InitializeSession(const QuicCryptoServerConfig& crypto_config); 63 64 const QuicCryptoServerStream* crypto_stream() const { 65 return crypto_stream_.get(); 66 } 67 68 // Override base class to process FEC config received from client. 69 virtual void OnConfigNegotiated() OVERRIDE; 70 71 void set_serving_region(string serving_region) { 72 serving_region_ = serving_region; 73 } 74 75 protected: 76 // QuicSession methods: 77 virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE; 78 virtual QuicDataStream* CreateOutgoingDataStream() OVERRIDE; 79 virtual QuicCryptoServerStream* GetCryptoStream() OVERRIDE; 80 81 // If we should create an incoming stream, returns true. Otherwise 82 // does error handling, including communicating the error to the client and 83 // possibly closing the connection, and returns false. 84 virtual bool ShouldCreateIncomingDataStream(QuicStreamId id); 85 86 virtual QuicCryptoServerStream* CreateQuicCryptoServerStream( 87 const QuicCryptoServerConfig& crypto_config); 88 89 private: 90 friend class test::QuicServerSessionPeer; 91 92 scoped_ptr<QuicCryptoServerStream> crypto_stream_; 93 QuicServerSessionVisitor* visitor_; 94 95 // The most recent bandwidth estimate sent to the client. 96 QuicBandwidth bandwidth_estimate_sent_to_client_; 97 98 // Text describing server location. Sent to the client as part of the bandwith 99 // estimate in the source-address token. Optional, can be left empty. 100 string serving_region_; 101 102 // Time at which we send the last SCUP to the client. 103 QuicTime last_server_config_update_time_; 104 105 DISALLOW_COPY_AND_ASSIGN(QuicServerSession); 106}; 107 108} // namespace tools 109} // namespace net 110 111#endif // NET_TOOLS_QUIC_QUIC_SERVER_SESSION_H_ 112