Require a CTVerifier and CTPolicyEnforcer for TLS/QUIC sockets

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 2013 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/spdy/spdy_test_util_common.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <memory>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "net/base/host_port_pair.h"
+#include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/mock_cert_verifier.h"
+#include "net/cert/multi_log_ct_verifier.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/transport_client_socket_pool.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_framer.h"
@@ skipping 294 matching lines @@
 MockECSignatureCreatorFactory::~MockECSignatureCreatorFactory() {
   crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
 }
 
 crypto::ECSignatureCreator* MockECSignatureCreatorFactory::Create(
     crypto::ECPrivateKey* key) {
   return new MockECSignatureCreator(key);
 }
 
 SpdySessionDependencies::SpdySessionDependencies(NextProto protocol)
+    : SpdySessionDependencies(protocol, ProxyService::CreateDirect()) {}
+
+SpdySessionDependencies::SpdySessionDependencies(
+    NextProto protocol,
+    std::unique_ptr<ProxyService> proxy_service)
     : host_resolver(new MockCachingHostResolver),
       cert_verifier(new MockCertVerifier),
       channel_id_service(nullptr),
       transport_security_state(new TransportSecurityState),
-      proxy_service(ProxyService::CreateDirect()),
+      cert_transparency_verifier(new MultiLogCTVerifier),
+      ct_policy_enforcer(new CTPolicyEnforcer),
+      proxy_service(std::move(proxy_service)),
       ssl_config_service(new SSLConfigServiceDefaults),
       socket_factory(new MockClientSocketFactory),
       http_auth_handler_factory(
           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
       enable_ip_pooling(true),
       enable_ping(false),
       enable_user_alternate_protocol_ports(false),
       enable_npn(false),
       enable_priority_dependencies(true),
       enable_spdy31(true),
       enable_quic(false),
       enable_alternative_service_for_insecure_origins(true),
       protocol(protocol),
       session_max_recv_window_size(
           SpdySession::GetDefaultInitialWindowSize(protocol)),
       stream_max_recv_window_size(
           SpdySession::GetDefaultInitialWindowSize(protocol)),
       time_func(&base::TimeTicks::Now),
       enable_alternative_service_with_different_host(true),
       net_log(NULL) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 
   // Note: The CancelledTransaction test does cleanup by running all
   // tasks in the message loop (RunAllPending).  Unfortunately, that
   // doesn't clean up tasks on the host resolver thread; and
   // TCPConnectJob is currently not cancellable.  Using synchronous
   // lookups allows the test to shutdown cleanly.  Until we have
   // cancellable TCPConnectJobs, use synchronous lookups.
   host_resolver->set_synchronous_mode(true);

[Ryan Sleevi, 2016/06/15 01:25:05]

Interestingly, this *wasn't* set if you supplied a proxy explicitly, which
caused other tests to behave non-deterministically. "WTF"

 }
 
-SpdySessionDependencies::SpdySessionDependencies(
-    NextProto protocol,
-    std::unique_ptr<ProxyService> proxy_service)
-    : host_resolver(new MockHostResolver),
-      cert_verifier(new MockCertVerifier),
-      channel_id_service(nullptr),
-      transport_security_state(new TransportSecurityState),
-      proxy_service(std::move(proxy_service)),
-      ssl_config_service(new SSLConfigServiceDefaults),
-      socket_factory(new MockClientSocketFactory),
-      http_auth_handler_factory(
-          HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
-      enable_ip_pooling(true),
-      enable_ping(false),
-      enable_user_alternate_protocol_ports(false),
-      enable_npn(false),
-      enable_priority_dependencies(true),
-      enable_spdy31(true),
-      enable_quic(false),
-      enable_alternative_service_for_insecure_origins(true),
-      protocol(protocol),
-      session_max_recv_window_size(
-          SpdySession::GetDefaultInitialWindowSize(protocol)),
-      stream_max_recv_window_size(
-          SpdySession::GetDefaultInitialWindowSize(protocol)),
-      time_func(&base::TimeTicks::Now),
-      enable_alternative_service_with_different_host(true),
-      net_log(NULL) {
-  DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
-}
-
 SpdySessionDependencies::~SpdySessionDependencies() {}
 
 // static
 std::unique_ptr<HttpNetworkSession> SpdySessionDependencies::SpdyCreateSession(
     SpdySessionDependencies* session_deps) {
   HttpNetworkSession::Params params = CreateSessionParams(session_deps);
   params.client_socket_factory = session_deps->socket_factory.get();
   std::unique_ptr<HttpNetworkSession> http_session(
       new HttpNetworkSession(params));
   SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
   pool_peer.SetEnableSendingInitialData(false);
   return http_session;
 }
 
 // static
 HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
     SpdySessionDependencies* session_deps) {
   DCHECK(next_proto_is_spdy(session_deps->protocol)) <<
       "Invalid protocol: " << session_deps->protocol;
 
   HttpNetworkSession::Params params;
   params.host_resolver = session_deps->host_resolver.get();
   params.cert_verifier = session_deps->cert_verifier.get();
   params.channel_id_service = session_deps->channel_id_service.get();
   params.transport_security_state =
       session_deps->transport_security_state.get();
+  params.cert_transparency_verifier =
+      session_deps->cert_transparency_verifier.get();
+  params.ct_policy_enforcer = session_deps->ct_policy_enforcer.get();
   params.proxy_service = session_deps->proxy_service.get();
   params.ssl_config_service = session_deps->ssl_config_service.get();
   params.http_auth_handler_factory =
       session_deps->http_auth_handler_factory.get();
   params.http_server_properties =
       session_deps->http_server_properties.GetWeakPtr();
   params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
   params.enable_user_alternate_protocol_ports =
       session_deps->enable_user_alternate_protocol_ports;
   params.enable_npn = session_deps->enable_npn;
@@ skipping 881 matching lines @@
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net