URLRequestContextBuilder should initialize a default CT state

net/url_request/url_request_context_builder.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/url_request/url_request_context_builder.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/sdch_manager.h"
 #include "net/cert/cert_verifier.h"
+#include "net/cert/ct_known_logs.h"
+#include "net/cert/ct_log_verifier.h"
 #include "net/cert/ct_policy_enforcer.h"
+#include "net/cert/ct_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/http/transport_security_persister.h"
 #include "net/http/transport_security_state.h"
@@ skipping 207 matching lines @@
   http_cache_enabled_ = false;
   http_cache_params_ = HttpCacheParams();
 }
 
 void URLRequestContextBuilder::SetSpdyAndQuicEnabled(bool spdy_enabled,
                                                      bool quic_enabled) {
   http_network_session_params_.enable_http2 = spdy_enabled;
   http_network_session_params_.enable_quic = quic_enabled;
 }
 
+void URLRequestContextBuilder::set_ct_verifier(

[eroman, 2016/07/19 22:55:40]

Why the naming difference from SetCertVerifier() / SetInterceptors() etc.

Arguably those other two are the aberrations in-so-far as chromium style is
concerned.

But it does mean this new function is not consistent within
url_request_context_builder.h

[Ryan Sleevi, 2016/07/19 23:04:53]

It's consistent with the dominant style, and SetCertVerifier/SetInterceptors
seemed to be the inconsistent one.

The reason for not inlining in the header was because std::move would require
including the full header

+    std::unique_ptr<CTVerifier> ct_verifier) {
+  ct_verifier_ = std::move(ct_verifier);
+}
+
 void URLRequestContextBuilder::SetCertVerifier(
     std::unique_ptr<CertVerifier> cert_verifier) {
   cert_verifier_ = std::move(cert_verifier);
 }
 
 void URLRequestContextBuilder::SetInterceptors(
     std::vector<std::unique_ptr<URLRequestInterceptor>>
         url_request_interceptors) {
   url_request_interceptors_ = std::move(url_request_interceptors);
 }
@@ skipping 118 matching lines @@
     storage->set_http_server_properties(
         std::unique_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
   }
 
   if (cert_verifier_) {
     storage->set_cert_verifier(std::move(cert_verifier_));
   } else {
     storage->set_cert_verifier(CertVerifier::CreateDefault());
   }
 
-  storage->set_cert_transparency_verifier(
-      base::MakeUnique<MultiLogCTVerifier>());
+  if (ct_verifier_) {
+    storage->set_cert_transparency_verifier(std::move(ct_verifier_));
+  } else {
+    std::unique_ptr<MultiLogCTVerifier> ct_verifier =
+        base::MakeUnique<MultiLogCTVerifier>();
+    ct_verifier->AddLogs(ct::CreateLogVerifiersForKnownLogs());
+    storage->set_cert_transparency_verifier(std::move(ct_verifier));
+  }
   storage->set_ct_policy_enforcer(base::MakeUnique<CTPolicyEnforcer>());
 
   if (throttling_enabled_) {
     storage->set_throttler_manager(
         base::WrapUnique(new URLRequestThrottlerManager()));
   }
 
   if (backoff_enabled_) {
     storage->set_backoff_manager(
         base::WrapUnique(new URLRequestBackoffManager()));
@@ skipping 117 matching lines @@
     }
     url_request_interceptors_.clear();
   }
   storage->set_job_factory(std::move(top_job_factory));
   // TODO(willchan): Support sdch.
 
   return std::move(context);
 }
 
 }  // namespace net