relnote: remove insecure QUIC support

net/quic/quic_stream_factory_test.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/quic/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/test_data_directory.h"
@@ skipping 69 matching lines @@
 }  // namespace anonymous
 
 class QuicStreamFactoryPeer {
  public:
   static QuicCryptoClientConfig* GetCryptoConfig(QuicStreamFactory* factory) {
     return &factory->crypto_config_;
   }
 
   static bool HasActiveSession(QuicStreamFactory* factory,
                                const HostPortPair& host_port_pair) {
-    QuicServerId server_id(host_port_pair, /*is_https=*/true,
-                           PRIVACY_MODE_DISABLED);
+    QuicServerId server_id(host_port_pair, PRIVACY_MODE_DISABLED);
     return factory->HasActiveSession(server_id);
   }
 
   static QuicChromiumClientSession* GetActiveSession(
       QuicStreamFactory* factory,
       const HostPortPair& host_port_pair) {
-    QuicServerId server_id(host_port_pair, /*is_https=*/true,
-                           PRIVACY_MODE_DISABLED);
+    QuicServerId server_id(host_port_pair, PRIVACY_MODE_DISABLED);
     DCHECK(factory->HasActiveSession(server_id));
     return factory->active_sessions_[server_id];
   }
 
   static scoped_ptr<QuicHttpStream> CreateFromSession(
       QuicStreamFactory* factory,
       QuicChromiumClientSession* session) {
     return factory->CreateFromSession(session);
   }
 
@@ skipping 1416 matching lines @@
 
   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
     string r1_host_name("r1");
     string r2_host_name("r2");
     r1_host_name.append(cannoncial_suffixes[i]);
     r2_host_name.append(cannoncial_suffixes[i]);
 
     HostPortPair host_port_pair1(r1_host_name, 80);
     QuicCryptoClientConfig* crypto_config =
         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
-    QuicServerId server_id1(host_port_pair1, /*is_https=*/true, privacy_mode_);
+    QuicServerId server_id1(host_port_pair1, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached1 =
         crypto_config->LookupOrCreate(server_id1);
     EXPECT_FALSE(cached1->proof_valid());
     EXPECT_TRUE(cached1->source_address_token().empty());
 
     // Mutate the cached1 to have different data.
     // TODO(rtenneti): mutate other members of CachedState.
     cached1->set_source_address_token(r1_host_name);
     cached1->SetProofValid();
 
     HostPortPair host_port_pair2(r2_host_name, 80);
-    QuicServerId server_id2(host_port_pair2, /*is_https=*/true, privacy_mode_);
+    QuicServerId server_id2(host_port_pair2, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached2 =
         crypto_config->LookupOrCreate(server_id2);
     EXPECT_EQ(cached1->source_address_token(), cached2->source_address_token());
     EXPECT_TRUE(cached2->proof_valid());
   }
 }
 
 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
   vector<string> cannoncial_suffixes;
   cannoncial_suffixes.push_back(string(".c.youtube.com"));
   cannoncial_suffixes.push_back(string(".googlevideo.com"));
 
   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
     string r3_host_name("r3");
     string r4_host_name("r4");
     r3_host_name.append(cannoncial_suffixes[i]);
     r4_host_name.append(cannoncial_suffixes[i]);
 
     HostPortPair host_port_pair1(r3_host_name, 80);
     QuicCryptoClientConfig* crypto_config =
         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
-    QuicServerId server_id1(host_port_pair1, /*is_https=*/true, privacy_mode_);
+    QuicServerId server_id1(host_port_pair1, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached1 =
         crypto_config->LookupOrCreate(server_id1);
     EXPECT_FALSE(cached1->proof_valid());
     EXPECT_TRUE(cached1->source_address_token().empty());
 
     // Mutate the cached1 to have different data.
     // TODO(rtenneti): mutate other members of CachedState.
     cached1->set_source_address_token(r3_host_name);
     cached1->SetProofInvalid();
 
     HostPortPair host_port_pair2(r4_host_name, 80);
-    QuicServerId server_id2(host_port_pair2, /*is_https=*/true, privacy_mode_);
+    QuicServerId server_id2(host_port_pair2, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached2 =
         crypto_config->LookupOrCreate(server_id2);
     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
     EXPECT_TRUE(cached2->source_address_token().empty());
     EXPECT_FALSE(cached2->proof_valid());
   }
 }
 
 TEST_P(QuicStreamFactoryTest, RacingConnections) {
   if (!GetParam().enable_connection_racing)
@@ skipping 25 matching lines @@
   http_server_properties_.SetAlternativeServices(
       host_port_pair_, alternative_service_info_vector);
 
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::ZERO_RTT);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
-  QuicServerId server_id(host_port_pair_, /*is_https=*/true, privacy_mode_);
+  QuicServerId server_id(host_port_pair_, privacy_mode_);
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
                             "GET", net_log_, callback_.callback()));
   EXPECT_EQ(2u,
             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
 
   runner_->RunNextTask();
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ skipping 939 matching lines @@
   const AlternativeService alternative_service1(QUIC, host_port_pair_.host(),
                                                 host_port_pair_.port());
   AlternativeServiceInfoVector alternative_service_info_vector;
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service1, 1.0, expiration));
 
   http_server_properties_.SetAlternativeServices(
       host_port_pair_, alternative_service_info_vector);
 
-  QuicServerId quic_server_id("www.google.com", 80, false,
-                              PRIVACY_MODE_DISABLED);
+  QuicServerId quic_server_id("www.google.com", 80, PRIVACY_MODE_DISABLED);
   QuicServerInfoFactory* quic_server_info_factory =
       new PropertiesBasedQuicServerInfoFactory(
           http_server_properties_.GetWeakPtr());
   factory_.set_quic_server_info_factory(quic_server_info_factory);
 
   scoped_ptr<QuicServerInfo> quic_server_info(
       quic_server_info_factory->GetForServer(quic_server_id));
 
   // Update quic_server_info's server_config and persist it.
   QuicServerInfo::State* state = quic_server_info->mutable_state();
@@ skipping 128 matching lines @@
   EXPECT_EQ(1u, observer.executed_count());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net