Remove CertTrustAnchorProvider from net

net/cert/caching_cert_verifier.cc

 // Copyright 2016 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/cert/caching_cert_verifier.h"
 
 #include "base/time/time.h"
 #include "net/base/net_errors.h"
-#include "net/cert/cert_trust_anchor_provider.h"
 
 namespace net {
 
 namespace {
 
 // The maximum number of cache entries to use for the ExpiringCache.
 const unsigned kMaxCacheEntries = 256;
 
 // The number of seconds to cache entries.
 const unsigned kTTLSecs = 1800;  // 30 minutes.
 
 }  // namespace
 
 CachingCertVerifier::CachingCertVerifier(std::unique_ptr<CertVerifier> verifier)
     : verifier_(std::move(verifier)),
-      trust_anchor_provider_(nullptr),
       cache_(kMaxCacheEntries),
       requests_(0u),
       cache_hits_(0u) {
   CertDatabase::GetInstance()->AddObserver(this);
 }
 
 CachingCertVerifier::~CachingCertVerifier() {
   CertDatabase::GetInstance()->RemoveObserver(this);
 }
 
-void CachingCertVerifier::SetCertTrustAnchorProvider(
-    CertTrustAnchorProvider* trust_anchor_provider) {
-  DCHECK(!trust_anchor_provider_);
-  trust_anchor_provider_ = trust_anchor_provider;
-}
-
 int CachingCertVerifier::Verify(const CertVerifier::RequestParams& params,
                                 CRLSet* crl_set,
                                 CertVerifyResult* verify_result,
                                 const CompletionCallback& callback,
                                 std::unique_ptr<Request>* out_req,
                                 const BoundNetLog& net_log) {
   out_req->reset();
 
   requests_++;
 
-  CertificateList additional_trust_anchors(params.additional_trust_anchors());
-  if (trust_anchor_provider_) {
-    const CertificateList& trust_anchors =
-        trust_anchor_provider_->GetAdditionalTrustAnchors();
-    additional_trust_anchors.insert(additional_trust_anchors.begin(),
-                                    trust_anchors.begin(), trust_anchors.end());
-  }
-
-  const CertVerifier::RequestParams new_params(
-      params.certificate(), params.hostname(), params.flags(),
-      params.ocsp_response(), additional_trust_anchors);
   const CertVerificationCache::value_type* cached_entry =
-      cache_.Get(new_params, CacheValidityPeriod(base::Time::Now()));
+      cache_.Get(params, CacheValidityPeriod(base::Time::Now()));
   if (cached_entry) {
     ++cache_hits_;
     *verify_result = cached_entry->result;
     return cached_entry->error;
   }
 
   base::Time start_time = base::Time::Now();
   CompletionCallback caching_callback = base::Bind(
-      &CachingCertVerifier::OnRequestFinished, base::Unretained(this),
-      new_params, start_time, callback, verify_result);
-  int result = verifier_->Verify(new_params, crl_set, verify_result,
+      &CachingCertVerifier::OnRequestFinished, base::Unretained(this), params,
+      start_time, callback, verify_result);
+  int result = verifier_->Verify(params, crl_set, verify_result,
                                  caching_callback, out_req, net_log);
   if (result != ERR_IO_PENDING) {
     // Synchronous completion; add directly to cache.
-    AddResultToCache(new_params, start_time, *verify_result, result);
+    AddResultToCache(params, start_time, *verify_result, result);
   }
 
   return result;
 }
 
 bool CachingCertVerifier::SupportsOCSPStapling() {
   return verifier_->SupportsOCSPStapling();
 }
 
 bool CachingCertVerifier::AddEntry(const RequestParams& params,
@@ skipping 133 matching lines @@
 
 void CachingCertVerifier::ClearCache() {
   cache_.Clear();
 }
 
 size_t CachingCertVerifier::GetCacheSize() const {
   return cache_.size();
 }
 
 }  // namespace net