Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(793)

Unified Diff: net/tools/quic/test_tools/quic_test_client.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/tools/quic/test_tools/quic_test_client.h ('k') | net/tools/quic/test_tools/quic_test_utils.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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
« no previous file with comments | « net/tools/quic/test_tools/quic_test_client.h ('k') | net/tools/quic/test_tools/quic_test_utils.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698