blob: 13b65b1b532723996f60aa08696b0f68b7f1602e [file] [log] [blame] [edit]
// Copyright (c) 2017 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.
#ifndef QUICHE_QUIC_QUARTC_QUARTC_FAKES_H_
#define QUICHE_QUIC_QUARTC_QUARTC_FAKES_H_
#include <string>
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_clock.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_endpoint.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_session.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_stream.h"
namespace quic {
class FakeQuartcEndpointDelegate : public QuartcEndpoint::Delegate {
public:
explicit FakeQuartcEndpointDelegate(QuartcStream::Delegate* stream_delegate,
const QuicClock* clock)
: stream_delegate_(stream_delegate), clock_(clock) {}
void OnSessionCreated(QuartcSession* session) override {
CHECK_NE(session, nullptr);
session_ = session;
session_->StartCryptoHandshake();
++num_sessions_created_;
}
void OnConnectionWritable() override {
QUIC_LOG(INFO) << "Connection writable!";
if (!writable_time_.IsInitialized()) {
writable_time_ = clock_->Now();
}
}
// Called when peers have established forward-secure encryption
void OnCryptoHandshakeComplete() override {
QUIC_LOG(INFO) << "Crypto handshake complete!";
crypto_handshake_time_ = clock_->Now();
}
// Called when connection closes locally, or remotely by peer.
void OnConnectionClosed(QuicErrorCode error_code,
const std::string& error_details,
ConnectionCloseSource source) override {
connected_ = false;
}
// Called when an incoming QUIC stream is created.
void OnIncomingStream(QuartcStream* quartc_stream) override {
last_incoming_stream_ = quartc_stream;
last_incoming_stream_->SetDelegate(stream_delegate_);
}
void OnMessageReceived(QuicStringPiece message) override {
incoming_messages_.emplace_back(message);
}
void OnMessageSent(int64_t datagram_id) override {
sent_datagram_ids_.push_back(datagram_id);
}
void OnCongestionControlChange(QuicBandwidth bandwidth_estimate,
QuicBandwidth pacing_rate,
QuicTime::Delta latest_rtt) override {}
QuartcSession* session() { return session_; }
int num_sessions_created() const { return num_sessions_created_; }
QuartcStream* last_incoming_stream() const { return last_incoming_stream_; }
// Returns all received messages.
const std::vector<std::string>& incoming_messages() const {
return incoming_messages_;
}
// Returns all sent datagram ids in the order sent.
const std::vector<int64_t>& sent_datagram_ids() const {
return sent_datagram_ids_;
}
bool connected() const { return connected_; }
QuicTime writable_time() const { return writable_time_; }
QuicTime crypto_handshake_time() const { return crypto_handshake_time_; }
private:
// Current session.
QuartcSession* session_ = nullptr;
// Number of new sessions created by the endpoint.
int num_sessions_created_ = 0;
QuartcStream* last_incoming_stream_;
std::vector<std::string> incoming_messages_;
std::vector<int64_t> sent_datagram_ids_;
bool connected_ = true;
QuartcStream::Delegate* stream_delegate_;
QuicTime writable_time_ = QuicTime::Zero();
QuicTime crypto_handshake_time_ = QuicTime::Zero();
const QuicClock* clock_;
};
class FakeQuartcStreamDelegate : public QuartcStream::Delegate {
public:
size_t OnReceived(QuartcStream* stream,
iovec* iov,
size_t iov_length,
bool fin) override {
size_t bytes_consumed = 0;
for (size_t i = 0; i < iov_length; ++i) {
received_data_[stream->id()] += std::string(
static_cast<const char*>(iov[i].iov_base), iov[i].iov_len);
bytes_consumed += iov[i].iov_len;
}
return bytes_consumed;
}
void OnClose(QuartcStream* stream) override {
errors_[stream->id()] = stream->stream_error();
}
void OnBufferChanged(QuartcStream* stream) override {}
bool has_data() { return !received_data_.empty(); }
std::map<QuicStreamId, std::string> data() { return received_data_; }
QuicRstStreamErrorCode stream_error(QuicStreamId id) { return errors_[id]; }
private:
std::map<QuicStreamId, std::string> received_data_;
std::map<QuicStreamId, QuicRstStreamErrorCode> errors_;
};
} // namespace quic
#endif // QUICHE_QUIC_QUARTC_QUARTC_FAKES_H_