Allow TrustStore queries to be asynchronous.

net/cert/internal/trust_store_test_helpers.h

Index: net/cert/internal/trust_store_test_helpers.h
diff --git a/net/cert/internal/trust_store_test_helpers.h b/net/cert/internal/trust_store_test_helpers.h
new file mode 100644
index 0000000000000000000000000000000000000000..76df1d3454ac528c83a2e45d6f69f9d70c074f75
--- /dev/null
+++ b/net/cert/internal/trust_store_test_helpers.h
@@ -0,0 +1,68 @@
+// 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.
+
+#ifndef NET_CERT_INTERNAL_TRUST_STORE_TEST_HELPERS_H_
+#define NET_CERT_INTERNAL_TRUST_STORE_TEST_HELPERS_H_
+
+#include "base/callback.h"
+#include "base/run_loop.h"
+#include "net/cert/internal/trust_store.h"
+#include "net/cert/internal/trust_store_in_memory.h"
+
+namespace net {
+
+// Deletes the Request owned by |*req_owner|, then calls done_callback. Intended
+// to be passed as the TrustAnchorCallback to FindTrustAnchorsForCert to test
+// deleting the Request during the request callback.
+void TrustStoreRequestDeleter(std::unique_ptr<TrustStore::Request>* req_owner,
+                              base::Closure done_callback,

[eroman, 2016/08/23 18:30:10]

should this be a const-reference?

[mattm, 2016/08/26 02:24:43]

Done.

+                              std::unique_ptr<TrustAnchors> anchors);
+
+// Helper to record async results from a FindTrustAnchorsForCert call.
+class TrustAnchorResultRecorder {
+ public:
+  TrustAnchorResultRecorder();
+  ~TrustAnchorResultRecorder();
+
+  TrustStore::TrustAnchorCallback Callback();
+
+  void Run() { run_loop_.Run(); }
+
+  const TrustAnchors& matches() const { return *anchors_; }
+
+ private:
+  void OnGotAnchors(std::unique_ptr<TrustAnchors> anchors);
+
+  base::RunLoop run_loop_;
+  std::unique_ptr<TrustAnchors> anchors_;
+};
+
+// In-memory TrustStore that can return results synchronously, asynchronously,
+// or both.
+class TrustStoreInMemoryAsync : public TrustStore {
+ public:
+  TrustStoreInMemoryAsync();
+  ~TrustStoreInMemoryAsync() override;
+
+  // Adds |anchor| to the set of results that will be returned synchronously.
+  void AddSyncTrustAnchor(scoped_refptr<TrustAnchor> anchor);
+
+  // Adds |anchor| to the set of results that will be returned asynchronously.
+  void AddAsyncTrustAnchor(scoped_refptr<TrustAnchor> anchor);
+
+  // TrustStore implementation:
+  void FindTrustAnchorsForCert(
+      const ParsedCertificate* cert,
+      const TrustAnchorCallback& callback,
+      TrustAnchors* out_matches,
+      std::unique_ptr<Request>* out_req) const override;
+
+ private:
+  TrustStoreInMemory sync_store_;
+  TrustStoreInMemory async_store_;
+};
+
+}  // namespace net
+
+#endif  // NET_CERT_INTERNAL_TRUST_STORE_TEST_HELPERS_H_