blob: 81cae1283630acf01e7083b34a9ea6d1667831fe [file] [log] [blame]
// 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.
// A server specific QuicSession subclass.
#include <set>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/containers/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "net/quic/quic_crypto_server_stream.h"
#include "net/quic/quic_protocol.h"
#include "net/quic/quic_session.h"
namespace net {
class QuicBlockedWriterInterface;
class QuicConfig;
class QuicConnection;
class QuicCryptoServerConfig;
class ReliableQuicStream;
namespace tools {
namespace test {
class QuicServerSessionPeer;
} // namespace test
// An interface from the session to the entity owning the session.
// This lets the session notify its owner (the Dispatcher) when the connection
// is closed or blocked.
class QuicServerSessionVisitor {
virtual ~QuicServerSessionVisitor() {}
virtual void OnConnectionClosed(QuicConnectionId connection_id,
QuicErrorCode error) = 0;
virtual void OnWriteBlocked(QuicBlockedWriterInterface* blocked_writer) = 0;
class QuicServerSession : public QuicSession {
QuicServerSession(const QuicConfig& config,
QuicConnection* connection,
QuicServerSessionVisitor* visitor);
// Override the base class to notify the owner of the connection close.
void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
void OnWriteBlocked() override;
// Sends a server config update to the client, containing new bandwidth
// estimate.
void OnCongestionWindowChange(QuicTime now) override;
~QuicServerSession() override;
virtual void InitializeSession(const QuicCryptoServerConfig& crypto_config);
const QuicCryptoServerStream* crypto_stream() const {
return crypto_stream_.get();
// Override base class to process FEC config received from client.
void OnConfigNegotiated() override;
void set_serving_region(std::string serving_region) {
serving_region_ = serving_region;
// QuicSession methods:
QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override;
QuicDataStream* CreateOutgoingDataStream() override;
QuicCryptoServerStream* GetCryptoStream() override;
// If we should create an incoming stream, returns true. Otherwise
// does error handling, including communicating the error to the client and
// possibly closing the connection, and returns false.
virtual bool ShouldCreateIncomingDataStream(QuicStreamId id);
virtual QuicCryptoServerStream* CreateQuicCryptoServerStream(
const QuicCryptoServerConfig& crypto_config);
friend class test::QuicServerSessionPeer;
scoped_ptr<QuicCryptoServerStream> crypto_stream_;
QuicServerSessionVisitor* visitor_;
// The most recent bandwidth estimate sent to the client.
QuicBandwidth bandwidth_estimate_sent_to_client_;
// Text describing server location. Sent to the client as part of the bandwith
// estimate in the source-address token. Optional, can be left empty.
std::string serving_region_;
// Time at which we send the last SCUP to the client.
QuicTime last_scup_time_;
// Number of packets sent to the peer, at the time we last sent a SCUP.
int64 last_scup_sequence_number_;
} // namespace tools
} // namespace net