Add TrustStoreNSS and TrustStoreCollection

net/cert/internal/trust_store_test_helpers.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/internal/trust_store_test_helpers.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 23 matching lines @@
   }
 
   TrustStore::TrustAnchorsCallback callback_;
   base::WeakPtrFactory<TrustStoreInMemoryAsyncRequest> weak_ptr_factory_;
 };
 
 }  // namespace
 
 void TrustStoreRequestDeleter(std::unique_ptr<TrustStore::Request>* req_owner,
                               const base::Closure& done_callback,
-                              std::unique_ptr<TrustAnchors> anchors) {
+                              TrustAnchors anchors) {
   req_owner->reset();
   done_callback.Run();
 }
 
 TrustAnchorResultRecorder::TrustAnchorResultRecorder() = default;
 TrustAnchorResultRecorder::~TrustAnchorResultRecorder() = default;
 
 TrustStore::TrustAnchorsCallback TrustAnchorResultRecorder::Callback() {
   return base::Bind(&TrustAnchorResultRecorder::OnGotAnchors,
                     base::Unretained(this));
@@ skipping 11 matching lines @@
     scoped_refptr<TrustAnchor> anchor) {
   sync_store_.AddTrustAnchor(std::move(anchor));
 }
 
 void TrustStoreInMemoryAsync::AddAsyncTrustAnchor(
     scoped_refptr<TrustAnchor> anchor) {
   async_store_.AddTrustAnchor(std::move(anchor));
 }
 
 void TrustStoreInMemoryAsync::FindTrustAnchorsForCert(
-    const ParsedCertificate* cert,
+    const scoped_refptr<ParsedCertificate>& cert,
     const TrustAnchorsCallback& callback,
     TrustAnchors* synchronous_matches,
     std::unique_ptr<Request>* out_req) const {
   sync_store_.FindTrustAnchorsForCert(cert, TrustAnchorsCallback(),
                                       synchronous_matches, nullptr);
   if (!callback.is_null()) {
     TrustAnchors async_matches;
     async_store_.FindTrustAnchorsForCert(cert, TrustAnchorsCallback(),
                                          &async_matches, nullptr);
 
     std::unique_ptr<TrustStoreInMemoryAsyncRequest> req(
         base::MakeUnique<TrustStoreInMemoryAsyncRequest>(callback));
     req->PostTrustCallback(std::move(async_matches));
 
     *out_req = std::move(req);
   }
 }
 
 }  // namespace net