Remove insecure QUIC support

net/tools/quic/test_tools/quic_test_client.cc

 // 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"
@@ skipping 64 matching lines @@
   }
 
   const string& common_name() const { return common_name_; }
 
  private:
   string common_name_;
 };
 
 }  // anonymous namespace
 
-BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers,
-                           bool secure) {
+BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers) {
   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";
+    string full_uri = "https://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)
     : MockableQuicClient(server_address,
                          server_id,
                          QuicConfig(),
                          supported_versions,
                          epoll_server) {}
 
 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),
+                 epoll_server,
+                 new RecordingProofVerifier()),
       override_connection_id_(0),
       test_writer_(nullptr) {}
 
 MockableQuicClient::~MockableQuicClient() {
   if (connected()) {
     Disconnect();
   }
 }
 
 QuicPacketWriter* MockableQuicClient::CreateQuicPacketWriter() {
@@ skipping 15 matching lines @@
   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)
     : QuicTestClient(server_address,
                      server_hostname,
-                     secure,
                      QuicConfig(),
                      supported_versions) {}
 
 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_)),
       allow_bidirectional_data_(false) {
-  Initialize(secure);
+  Initialize();
 }
 
 QuicTestClient::QuicTestClient() : allow_bidirectional_data_(false) {}
 
 QuicTestClient::~QuicTestClient() {
   if (stream_) {
     stream_->set_visitor(nullptr);
   }
   client_->Disconnect();
 }
 
-void QuicTestClient::Initialize(bool secure) {
+void QuicTestClient::Initialize() {
   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;
   FillInRequest(uri, &message);
   return SendMessage(message);
 }
 
@@ skipping 52 matching lines @@
 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));
     }
   }
 
   // TODO(rtenneti): Add support for HTTPMessage::body_chunks().
   // CHECK(message.body_chunks().empty())
   //      << "HTTPMessage::body_chunks not supported";
 
-  scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers(),
-                                          secure_));
+  scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers()));
   ssize_t ret = GetOrCreateStreamAndSendRequest(
       (munged_headers.get() ? munged_headers.get() : message.headers()),
       message.body(), message.has_complete_message(), nullptr);
   WaitForWriteToFlush();
   return ret;
 }
 
 ssize_t QuicTestClient::SendData(const string& data, bool last_data) {
   return SendData(data, last_data, nullptr);
 }
@@ skipping 78 matching lines @@
   return stream_;
 }
 
 QuicErrorCode QuicTestClient::connection_error() {
   return client()->connection_error();
 }
 
 MockableQuicClient* QuicTestClient::client() { return client_.get(); }
 
 const string& QuicTestClient::cert_common_name() const {
-  return reinterpret_cast<RecordingProofVerifier*>(proof_verifier_)
+  return reinterpret_cast<RecordingProofVerifier*>(client_->proof_verifier())
       ->common_name();
 }
 
 QuicTagValueMap QuicTestClient::GetServerConfig() const {
   QuicCryptoClientConfig* config = client_->crypto_config();
   QuicCryptoClientConfig::CachedState* state =
       config->LookupOrCreate(client_->server_id());
   const CryptoHandshakeMessage* handshake_msg = state->GetServerConfig();
   if (handshake_msg != nullptr) {
     return handshake_msg->tag_value_map();
@@ skipping 218 matching lines @@
   message->headers()->SetRequestVersion(
       HTTPMessage::VersionToString(HttpConstants::HTTP_1_1));
   message->headers()->SetRequestMethod(
       HTTPMessage::MethodToString(HttpConstants::GET));
   message->headers()->SetRequestUri(uri);
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net