Index: net/tools/quic/test_tools/quic_test_client.cc |
diff --git a/net/tools/quic/test_tools/quic_test_client.cc b/net/tools/quic/test_tools/quic_test_client.cc |
deleted file mode 100644 |
index 94d55b4a564af44aa4d12dc70ee4e1ac1ca5c9f5..0000000000000000000000000000000000000000 |
--- a/net/tools/quic/test_tools/quic_test_client.cc |
+++ /dev/null |
@@ -1,563 +0,0 @@ |
-// 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. |
- |
-#include "net/tools/quic/test_tools/quic_test_client.h" |
- |
-#include "base/time/time.h" |
-#include "net/base/completion_callback.h" |
-#include "net/base/net_errors.h" |
-#include "net/cert/cert_verify_result.h" |
-#include "net/cert/x509_certificate.h" |
-#include "net/quic/crypto/proof_verifier.h" |
-#include "net/quic/quic_server_id.h" |
-#include "net/quic/test_tools/quic_connection_peer.h" |
-#include "net/quic/test_tools/quic_session_peer.h" |
-#include "net/quic/test_tools/quic_test_utils.h" |
-#include "net/quic/test_tools/reliable_quic_stream_peer.h" |
-#include "net/tools/balsa/balsa_headers.h" |
-#include "net/tools/quic/quic_epoll_connection_helper.h" |
-#include "net/tools/quic/quic_packet_writer_wrapper.h" |
-#include "net/tools/quic/quic_spdy_client_stream.h" |
-#include "net/tools/quic/test_tools/http_message.h" |
-#include "net/tools/quic/test_tools/quic_client_peer.h" |
-#include "url/gurl.h" |
- |
-using base::StringPiece; |
-using net::QuicServerId; |
-using net::test::QuicConnectionPeer; |
-using net::test::QuicSessionPeer; |
-using net::test::ReliableQuicStreamPeer; |
-using std::string; |
-using std::vector; |
- |
-namespace net { |
-namespace tools { |
-namespace test { |
-namespace { |
- |
-// RecordingProofVerifier accepts any certificate chain and records the common |
-// name of the leaf. |
-class RecordingProofVerifier : public ProofVerifier { |
- public: |
- // ProofVerifier interface. |
- QuicAsyncStatus VerifyProof(const string& hostname, |
- const string& server_config, |
- const vector<string>& certs, |
- const string& signature, |
- const ProofVerifyContext* context, |
- string* error_details, |
- scoped_ptr<ProofVerifyDetails>* details, |
- ProofVerifierCallback* callback) override { |
- common_name_.clear(); |
- if (certs.empty()) { |
- return QUIC_FAILURE; |
- } |
- |
- // Convert certs to X509Certificate. |
- vector<StringPiece> cert_pieces(certs.size()); |
- for (unsigned i = 0; i < certs.size(); i++) { |
- cert_pieces[i] = StringPiece(certs[i]); |
- } |
- scoped_refptr<net::X509Certificate> cert = |
- net::X509Certificate::CreateFromDERCertChain(cert_pieces); |
- if (!cert.get()) { |
- return QUIC_FAILURE; |
- } |
- |
- common_name_ = cert->subject().GetDisplayName(); |
- return QUIC_SUCCESS; |
- } |
- |
- const string& common_name() const { return common_name_; } |
- |
- private: |
- string common_name_; |
-}; |
- |
-} // anonymous namespace |
- |
-BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers, |
- bool secure) { |
- StringPiece uri = const_headers->request_uri(); |
- if (uri.empty()) { |
- return nullptr; |
- } |
- if (const_headers->request_method() == "CONNECT") { |
- return nullptr; |
- } |
- BalsaHeaders* headers = new BalsaHeaders; |
- headers->CopyFrom(*const_headers); |
- if (!uri.starts_with("https://") && |
- !uri.starts_with("http://")) { |
- // If we have a relative URL, set some defaults. |
- string full_uri = secure ? "https://www.google.com" : |
- "http://www.google.com"; |
- full_uri.append(uri.as_string()); |
- headers->SetRequestUri(full_uri); |
- } |
- return headers; |
-} |
- |
-MockableQuicClient::MockableQuicClient( |
- IPEndPoint server_address, |
- const QuicServerId& server_id, |
- const QuicVersionVector& supported_versions, |
- EpollServer* epoll_server) |
- : QuicClient(server_address, |
- server_id, |
- supported_versions, |
- epoll_server), |
- override_connection_id_(0), |
- test_writer_(nullptr) {} |
- |
-MockableQuicClient::MockableQuicClient( |
- IPEndPoint server_address, |
- const QuicServerId& server_id, |
- const QuicConfig& config, |
- const QuicVersionVector& supported_versions, |
- EpollServer* epoll_server) |
- : QuicClient(server_address, |
- server_id, |
- supported_versions, |
- config, |
- epoll_server), |
- override_connection_id_(0), |
- test_writer_(nullptr) {} |
- |
-MockableQuicClient::~MockableQuicClient() { |
- if (connected()) { |
- Disconnect(); |
- } |
-} |
- |
-QuicPacketWriter* MockableQuicClient::CreateQuicPacketWriter() { |
- QuicPacketWriter* writer = QuicClient::CreateQuicPacketWriter(); |
- if (!test_writer_) { |
- return writer; |
- } |
- test_writer_->set_writer(writer); |
- return test_writer_; |
-} |
- |
-QuicConnectionId MockableQuicClient::GenerateConnectionId() { |
- return override_connection_id_ ? override_connection_id_ |
- : QuicClient::GenerateConnectionId(); |
-} |
- |
-// Takes ownership of writer. |
-void MockableQuicClient::UseWriter(QuicPacketWriterWrapper* writer) { |
- CHECK(test_writer_ == nullptr); |
- test_writer_ = writer; |
-} |
- |
-void MockableQuicClient::UseConnectionId(QuicConnectionId connection_id) { |
- override_connection_id_ = connection_id; |
-} |
- |
-QuicTestClient::QuicTestClient(IPEndPoint server_address, |
- const string& server_hostname, |
- bool secure, |
- const QuicVersionVector& supported_versions) |
- : client_(new MockableQuicClient(server_address, |
- QuicServerId(server_hostname, |
- server_address.port(), |
- secure, |
- PRIVACY_MODE_DISABLED), |
- supported_versions, |
- &epoll_server_)) { |
- Initialize(secure); |
-} |
- |
-QuicTestClient::QuicTestClient( |
- IPEndPoint server_address, |
- const string& server_hostname, |
- bool secure, |
- const QuicConfig& config, |
- const QuicVersionVector& supported_versions) |
- : client_( |
- new MockableQuicClient(server_address, |
- QuicServerId(server_hostname, |
- server_address.port(), |
- secure, |
- PRIVACY_MODE_DISABLED), |
- config, |
- supported_versions, |
- &epoll_server_)) { |
- Initialize(secure); |
-} |
- |
-QuicTestClient::QuicTestClient() { |
-} |
- |
-QuicTestClient::~QuicTestClient() { |
- if (stream_) { |
- stream_->set_visitor(nullptr); |
- } |
-} |
- |
-void QuicTestClient::Initialize(bool secure) { |
- priority_ = 3; |
- connect_attempted_ = false; |
- secure_ = secure; |
- auto_reconnect_ = false; |
- buffer_body_ = true; |
- fec_policy_ = FEC_PROTECT_OPTIONAL; |
- proof_verifier_ = nullptr; |
- ClearPerRequestState(); |
- ExpectCertificates(secure_); |
- // As chrome will generally do this, we want it to be the default when it's |
- // not overridden. |
- if (!client_->config()->HasSetBytesForConnectionIdToSend()) { |
- client_->config()->SetBytesForConnectionIdToSend(0); |
- } |
-} |
- |
-void QuicTestClient::ExpectCertificates(bool on) { |
- if (on) { |
- proof_verifier_ = new RecordingProofVerifier; |
- client_->SetProofVerifier(proof_verifier_); |
- } else { |
- proof_verifier_ = nullptr; |
- client_->SetProofVerifier(nullptr); |
- } |
-} |
- |
-void QuicTestClient::SetUserAgentID(const string& user_agent_id) { |
- client_->SetUserAgentID(user_agent_id); |
-} |
- |
-ssize_t QuicTestClient::SendRequest(const string& uri) { |
- HTTPMessage message(HttpConstants::HTTP_1_1, |
- HttpConstants::GET, |
- uri); |
- return SendMessage(message); |
-} |
- |
-ssize_t QuicTestClient::SendMessage(const HTTPMessage& message) { |
- stream_ = nullptr; // Always force creation of a stream for SendMessage. |
- |
- // If we're not connected, try to find an sni hostname. |
- if (!connected()) { |
- GURL url(message.headers()->request_uri().as_string()); |
- if (!url.host().empty()) { |
- client_->set_server_id( |
- QuicServerId(url.host(), |
- url.EffectiveIntPort(), |
- url.SchemeIs("https"), |
- PRIVACY_MODE_DISABLED)); |
- } |
- } |
- |
- QuicSpdyClientStream* stream = GetOrCreateStream(); |
- if (!stream) { return 0; } |
- |
- scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers(), |
- secure_)); |
- ssize_t ret = GetOrCreateStream()->SendRequest( |
- munged_headers.get() ? *munged_headers : *message.headers(), |
- message.body(), message.has_complete_message()); |
- WaitForWriteToFlush(); |
- return ret; |
-} |
- |
-ssize_t QuicTestClient::SendData(string data, bool last_data) { |
- return SendData(data, last_data, nullptr); |
-} |
- |
-ssize_t QuicTestClient::SendData(string data, |
- bool last_data, |
- QuicAckNotifier::DelegateInterface* delegate) { |
- QuicSpdyClientStream* stream = GetOrCreateStream(); |
- if (!stream) { return 0; } |
- GetOrCreateStream()->SendBody(data, last_data, delegate); |
- WaitForWriteToFlush(); |
- return data.length(); |
-} |
- |
-bool QuicTestClient::response_complete() const { |
- return response_complete_; |
-} |
- |
-int QuicTestClient::response_header_size() const { |
- return response_header_size_; |
-} |
- |
-int64 QuicTestClient::response_body_size() const { |
- return response_body_size_; |
-} |
- |
-bool QuicTestClient::buffer_body() const { |
- return buffer_body_; |
-} |
- |
-void QuicTestClient::set_buffer_body(bool buffer_body) { |
- buffer_body_ = buffer_body; |
-} |
- |
-bool QuicTestClient::ServerInLameDuckMode() const { |
- return false; |
-} |
- |
-const string& QuicTestClient::response_body() { |
- return response_; |
-} |
- |
-string QuicTestClient::SendCustomSynchronousRequest( |
- const HTTPMessage& message) { |
- SendMessage(message); |
- WaitForResponse(); |
- return response_; |
-} |
- |
-string QuicTestClient::SendSynchronousRequest(const string& uri) { |
- if (SendRequest(uri) == 0) { |
- DLOG(ERROR) << "Failed the request for uri:" << uri; |
- return ""; |
- } |
- WaitForResponse(); |
- return response_; |
-} |
- |
-QuicSpdyClientStream* QuicTestClient::GetOrCreateStream() { |
- if (!connect_attempted_ || auto_reconnect_) { |
- if (!connected()) { |
- Connect(); |
- } |
- if (!connected()) { |
- return nullptr; |
- } |
- } |
- if (!stream_) { |
- stream_ = client_->CreateReliableClientStream(); |
- if (stream_ == nullptr) { |
- return nullptr; |
- } |
- stream_->set_visitor(this); |
- reinterpret_cast<QuicSpdyClientStream*>(stream_)->set_priority(priority_); |
- // Set FEC policy on stream. |
- ReliableQuicStreamPeer::SetFecPolicy(stream_, fec_policy_); |
- } |
- |
- return stream_; |
-} |
- |
-QuicErrorCode QuicTestClient::connection_error() { |
- return client()->session()->error(); |
-} |
- |
-MockableQuicClient* QuicTestClient::client() { return client_.get(); } |
- |
-const string& QuicTestClient::cert_common_name() const { |
- return reinterpret_cast<RecordingProofVerifier*>(proof_verifier_) |
- ->common_name(); |
-} |
- |
-QuicTagValueMap QuicTestClient::GetServerConfig() const { |
- QuicCryptoClientConfig* config = |
- QuicClientPeer::GetCryptoConfig(client_.get()); |
- QuicCryptoClientConfig::CachedState* state = |
- config->LookupOrCreate(client_->server_id()); |
- const CryptoHandshakeMessage* handshake_msg = state->GetServerConfig(); |
- if (handshake_msg != nullptr) { |
- return handshake_msg->tag_value_map(); |
- } else { |
- return QuicTagValueMap(); |
- } |
-} |
- |
-bool QuicTestClient::connected() const { |
- return client_->connected(); |
-} |
- |
-void QuicTestClient::Connect() { |
- DCHECK(!connected()); |
- if (!connect_attempted_) { |
- client_->Initialize(); |
- } |
- client_->Connect(); |
- connect_attempted_ = true; |
-} |
- |
-void QuicTestClient::ResetConnection() { |
- Disconnect(); |
- Connect(); |
-} |
- |
-void QuicTestClient::Disconnect() { |
- client_->Disconnect(); |
- connect_attempted_ = false; |
-} |
- |
-IPEndPoint QuicTestClient::LocalSocketAddress() const { |
- return client_->client_address(); |
-} |
- |
-void QuicTestClient::ClearPerRequestState() { |
- stream_error_ = QUIC_STREAM_NO_ERROR; |
- stream_ = nullptr; |
- response_ = ""; |
- response_complete_ = false; |
- response_headers_complete_ = false; |
- headers_.Clear(); |
- bytes_read_ = 0; |
- bytes_written_ = 0; |
- response_header_size_ = 0; |
- response_body_size_ = 0; |
-} |
- |
-void QuicTestClient::WaitForResponseForMs(int timeout_ms) { |
- int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond; |
- int64 old_timeout_us = epoll_server()->timeout_in_us(); |
- if (timeout_us > 0) { |
- epoll_server()->set_timeout_in_us(timeout_us); |
- } |
- const QuicClock* clock = |
- QuicConnectionPeer::GetHelper(client()->session()->connection())-> |
- GetClock(); |
- QuicTime end_waiting_time = clock->Now().Add( |
- QuicTime::Delta::FromMicroseconds(timeout_us)); |
- while (stream_ != nullptr && |
- !client_->session()->IsClosedStream(stream_->id()) && |
- (timeout_us < 0 || clock->Now() < end_waiting_time)) { |
- client_->WaitForEvents(); |
- } |
- if (timeout_us > 0) { |
- epoll_server()->set_timeout_in_us(old_timeout_us); |
- } |
-} |
- |
-void QuicTestClient::WaitForInitialResponseForMs(int timeout_ms) { |
- int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond; |
- int64 old_timeout_us = epoll_server()->timeout_in_us(); |
- if (timeout_us > 0) { |
- epoll_server()->set_timeout_in_us(timeout_us); |
- } |
- const QuicClock* clock = |
- QuicConnectionPeer::GetHelper(client()->session()->connection())-> |
- GetClock(); |
- QuicTime end_waiting_time = clock->Now().Add( |
- QuicTime::Delta::FromMicroseconds(timeout_us)); |
- while (stream_ != nullptr && |
- !client_->session()->IsClosedStream(stream_->id()) && |
- stream_->stream_bytes_read() == 0 && |
- (timeout_us < 0 || clock->Now() < end_waiting_time)) { |
- client_->WaitForEvents(); |
- } |
- if (timeout_us > 0) { |
- epoll_server()->set_timeout_in_us(old_timeout_us); |
- } |
-} |
- |
-ssize_t QuicTestClient::Send(const void *buffer, size_t size) { |
- return SendData(string(static_cast<const char*>(buffer), size), false); |
-} |
- |
-bool QuicTestClient::response_headers_complete() const { |
- if (stream_ != nullptr) { |
- return stream_->headers_decompressed(); |
- } else { |
- return response_headers_complete_; |
- } |
-} |
- |
-const BalsaHeaders* QuicTestClient::response_headers() const { |
- if (stream_ != nullptr) { |
- return &stream_->headers(); |
- } else { |
- return &headers_; |
- } |
-} |
- |
-int64 QuicTestClient::response_size() const { |
- return bytes_read_; |
-} |
- |
-size_t QuicTestClient::bytes_read() const { |
- return bytes_read_; |
-} |
- |
-size_t QuicTestClient::bytes_written() const { |
- return bytes_written_; |
-} |
- |
-void QuicTestClient::OnClose(QuicDataStream* stream) { |
- if (stream_ != stream) { |
- return; |
- } |
- if (buffer_body()) { |
- // TODO(fnk): The stream still buffers the whole thing. Fix that. |
- response_ = stream_->data(); |
- } |
- response_complete_ = true; |
- response_headers_complete_ = stream_->headers_decompressed(); |
- headers_.CopyFrom(stream_->headers()); |
- stream_error_ = stream_->stream_error(); |
- bytes_read_ = stream_->stream_bytes_read() + stream_->header_bytes_read(); |
- bytes_written_ = |
- stream_->stream_bytes_written() + stream_->header_bytes_written(); |
- response_header_size_ = headers_.GetSizeForWriteBuffer(); |
- response_body_size_ = stream_->data().size(); |
- stream_ = nullptr; |
-} |
- |
-void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) { |
- client_->UseWriter(writer); |
-} |
- |
-void QuicTestClient::UseConnectionId(QuicConnectionId connection_id) { |
- DCHECK(!connected()); |
- client_->UseConnectionId(connection_id); |
-} |
- |
-ssize_t QuicTestClient::SendAndWaitForResponse(const void *buffer, |
- size_t size) { |
- LOG(DFATAL) << "Not implemented"; |
- return 0; |
-} |
- |
-void QuicTestClient::Bind(IPEndPoint* local_address) { |
- DLOG(WARNING) << "Bind will be done during connect"; |
-} |
- |
-string QuicTestClient::SerializeMessage(const HTTPMessage& message) { |
- LOG(DFATAL) << "Not implemented"; |
- return ""; |
-} |
- |
-IPAddressNumber QuicTestClient::bind_to_address() const { |
- return client_->bind_to_address(); |
-} |
- |
-void QuicTestClient::set_bind_to_address(IPAddressNumber address) { |
- client_->set_bind_to_address(address); |
-} |
- |
-const IPEndPoint& QuicTestClient::address() const { |
- LOG(DFATAL) << "Not implemented"; |
- return client_->server_address(); |
-} |
- |
-size_t QuicTestClient::requests_sent() const { |
- LOG(DFATAL) << "Not implemented"; |
- return 0; |
-} |
- |
-void QuicTestClient::WaitForWriteToFlush() { |
- while (connected() && client()->session()->HasDataToWrite()) { |
- client_->WaitForEvents(); |
- } |
-} |
- |
-void QuicTestClient::SetFecPolicy(FecPolicy fec_policy) { |
- fec_policy_ = fec_policy; |
- // Set policy for headers and crypto streams. |
- ReliableQuicStreamPeer::SetFecPolicy( |
- QuicSessionPeer::GetHeadersStream(client()->session()), fec_policy); |
- ReliableQuicStreamPeer::SetFecPolicy(client()->session()->GetCryptoStream(), |
- fec_policy); |
-} |
- |
-} // namespace test |
-} // namespace tools |
-} // namespace net |