Add QuicStreamFactory as an observer of an SSLConfigService

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 <ostream>
 #include <utility>
 
 #include "base/run_loop.h"
@@ skipping 32 matching lines @@
 #include "net/ssl/default_channel_id_store.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 using std::vector;
 
 namespace net {
 
+namespace {
+
+class MockSSLConfigService : public SSLConfigService {
+ public:
+  MockSSLConfigService() {}
+
+  void GetSSLConfig(SSLConfig* config) override { *config = config_; }
+
+ private:
+  ~MockSSLConfigService() override {}
+
+  SSLConfig config_;
+};
+
+}  // namespace
+
 namespace test {
 
 namespace {
 
 enum DestinationType {
   // In pooling tests with two requests for different origins to the same
   // destination, the destination should be
   SAME_AS_FIRST,   // the same as the first origin,
   SAME_AS_SECOND,  // the same as the second origin, or
   DIFFERENT,       // different from both.
@@ skipping 182 matching lines @@
 
  private:
   std::unique_ptr<NetworkChangeNotifier::DisableForTest>
       disable_network_change_notifier_for_tests_;
   std::unique_ptr<MockNetworkChangeNotifier> mock_network_change_notifier_;
 };
 
 class QuicStreamFactoryTestBase {
  protected:
   QuicStreamFactoryTestBase(QuicVersion version, bool enable_connection_racing)
-      : random_generator_(0),
+      : ssl_config_service_(new MockSSLConfigService),
+        random_generator_(0),
         clock_(new MockClock()),
         runner_(new TestTaskRunner(clock_)),
         version_(version),
         client_maker_(version_,
                       0,
                       clock_,
                       kDefaultServerHostName,
                       Perspective::IS_CLIENT),
         server_maker_(version_,
                       0,
@@ skipping 40 matching lines @@
     // If |factory_| was initialized, then it took over ownership of |clock_|.
     // If |factory_| was not initialized, then |clock_| needs to be destroyed.
     if (!factory_) {
       delete clock_;
     }
   }
 
   void Initialize() {
     DCHECK(!factory_);
     factory_.reset(new QuicStreamFactory(
-        net_log_.net_log(), &host_resolver_, &socket_factory_,
-        &http_server_properties_, cert_verifier_.get(), &ct_policy_enforcer_,
-        channel_id_service_.get(), &transport_security_state_,
-        cert_transparency_verifier_.get(),
+        net_log_.net_log(), &host_resolver_, ssl_config_service_.get(),
+        &socket_factory_, &http_server_properties_, cert_verifier_.get(),
+        &ct_policy_enforcer_, channel_id_service_.get(),
+        &transport_security_state_, cert_transparency_verifier_.get(),
         /*SocketPerformanceWatcherFactory*/ nullptr,
         &crypto_client_stream_factory_, &random_generator_, clock_,
         kDefaultMaxPacketSize, string(), SupportedVersions(version_),
         enable_port_selection_, always_require_handshake_confirmation_,
         disable_connection_pooling_, load_server_info_timeout_srtt_multiplier_,
         enable_connection_racing_, enable_non_blocking_io_, disable_disk_cache_,
         prefer_aes_, max_number_of_lossy_connections_, packet_loss_threshold_,
         max_disabled_reasons_, threshold_timeouts_with_open_streams_,
         threshold_public_resets_post_handshake_, receive_buffer_size_,
         delay_tcp_race_, /*max_server_configs_stored_in_properties*/ 0,
@@ skipping 137 matching lines @@
       bool should_include_version,
       bool fin) {
     SpdyHeaderBlock headers = server_maker_.GetResponseHeaders("200 OK");
     size_t spdy_headers_frame_len;
     return server_maker_.MakeResponseHeadersPacket(
         packet_number, stream_id, should_include_version, fin,
         std::move(headers), &spdy_headers_frame_len);
   }
 
   MockHostResolver host_resolver_;
+  scoped_refptr<SSLConfigService> ssl_config_service_;
   MockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
   MockClock* clock_;  // Owned by |factory_| once created.
   scoped_refptr<TestTaskRunner> runner_;
   QuicVersion version_;
   QuicTestPacketMaker client_maker_;
   QuicTestPacketMaker server_maker_;
   HttpServerPropertiesImpl http_server_properties_;
   std::unique_ptr<CertVerifier> cert_verifier_;
@@ skipping 1908 matching lines @@
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<QuicHttpStream> stream = request.CreateStream();
   HttpRequestInfo request_info;
   EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
                                          net_log_, CompletionCallback()));
 
-  factory_->OnSSLConfigChanged();
+  ssl_config_service_->NotifySSLConfigChange();

[Ryan Hamilton, 2016/06/29 23:16:15]

Well, that was easy!

   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
   EXPECT_FALSE(factory_->require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_pair_, privacy_mode_,
@@ skipping 1915 matching lines @@
   EXPECT_NE(session1, session2);
 
   EXPECT_EQ(QuicServerId(origin1_, privacy_mode_), session1->server_id());
   EXPECT_EQ(QuicServerId(origin2_, privacy_mode_), session2->server_id());
 
   EXPECT_TRUE(AllDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net