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