Add CertIssuerSource interface and CertIssuerSourceStatic implementation.

net/cert/internal/cert_source_static_unittest.cc

Index: net/cert/internal/cert_source_static_unittest.cc
diff --git a/net/cert/internal/cert_source_static_unittest.cc b/net/cert/internal/cert_source_static_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e97eaf637c1745c5a25a23f69fd4d2bcfcc4166c
--- /dev/null
+++ b/net/cert/internal/cert_source_static_unittest.cc
@@ -0,0 +1,135 @@
+// 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/cert_source_static.h"
+
+#include "base/bind.h"
+#include "net/cert/internal/parsed_certificate.h"
+#include "net/cert/internal/test_helpers.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+void NotCalled(CertSource::Request* req) {
+  ADD_FAILURE() << "NotCalled was called";
+}
+
+::testing::AssertionResult ReadTestPem(const std::string& file_name,
+                                       const std::string& block_name,
+                                       std::string* result) {
+  const PemBlockMapping mappings[] = {
+      {block_name.c_str(), result},
+  };
+
+  return ReadTestDataFromPemFile(file_name, mappings);
+}
+
+::testing::AssertionResult ReadTestCert(
+    const std::string& file_name,
+    scoped_refptr<ParsedCertificate>* result) {
+  std::string der;
+  ::testing::AssertionResult r = ReadTestPem(
+      "net/data/cert_source_static_unittest/" + file_name, "CERTIFICATE", &der);
+  if (!r)
+    return r;
+  *result = ParsedCertificate::CreateFromCertificateCopy(der);
+  if (!*result)
+    return ::testing::AssertionFailure() << "CreateFromCertificateCopy failed";
+  return ::testing::AssertionSuccess();
+}
+
+class CertSourceStaticTest : public ::testing::Test {
+ public:
+  void SetUp() override {
+    ASSERT_TRUE(ReadTestCert("root.pem", &root_));
+    ASSERT_TRUE(ReadTestCert("b1_1.pem", &b1_1_));
+    ASSERT_TRUE(ReadTestCert("b1_2.pem", &b1_2_));
+    ASSERT_TRUE(ReadTestCert("b2_1.pem", &b2_1_));
+    ASSERT_TRUE(ReadTestCert("c1_1.pem", &c1_1_));
+    ASSERT_TRUE(ReadTestCert("c1_2.pem", &c1_2_));
+    ASSERT_TRUE(ReadTestCert("c2_1.pem", &c2_1_));
+  }
+
+  void AddAllCerts(CertSourceStatic* source) {
+    source->AddCert(root_);
+    source->AddCert(b1_1_);
+    source->AddCert(b1_2_);
+    source->AddCert(b2_1_);
+    source->AddCert(c1_1_);
+    source->AddCert(c1_2_);
+    source->AddCert(c2_1_);
+  }
+
+ protected:
+  scoped_refptr<ParsedCertificate> root_, b1_1_, b1_2_, b2_1_, c1_1_, c1_2_,

[eroman, 2016/06/01 20:52:10]

one per line please -- i believe that is the usual chrome style, even if more
verbose.

[mattm, 2016/06/01 22:20:41]

Done.

+      c2_1_;
+};
+
+TEST_F(CertSourceStaticTest, NoMatch) {
+  CertSourceStatic source;
+  source.AddCert(root_);
+
+  std::vector<scoped_refptr<ParsedCertificate>> issuers;
+  source.SyncGetIssuersOf(c1_1_.get(), &issuers);
+  ASSERT_EQ(0U, issuers.size());
+}
+
+TEST_F(CertSourceStaticTest, OneMatch) {
+  CertSourceStatic source;
+  AddAllCerts(&source);
+
+  std::vector<scoped_refptr<ParsedCertificate>> issuers;
+  source.SyncGetIssuersOf(b1_1_.get(), &issuers);
+  ASSERT_EQ(1U, issuers.size());
+  EXPECT_TRUE(issuers[0] == root_);
+
+  issuers.clear();
+  source.SyncGetIssuersOf(c2_1_.get(), &issuers);
+  ASSERT_EQ(1U, issuers.size());
+  EXPECT_TRUE(issuers[0] == b2_1_);
+}
+
+TEST_F(CertSourceStaticTest, MultipleMatches) {
+  CertSourceStatic source;
+  AddAllCerts(&source);
+
+  std::vector<scoped_refptr<ParsedCertificate>> issuers;
+  source.SyncGetIssuersOf(c1_1_.get(), &issuers);
+
+  ASSERT_EQ(2U, issuers.size());
+  EXPECT_TRUE(std::find(issuers.begin(), issuers.end(), b1_1_) !=
+              issuers.end());
+  EXPECT_TRUE(std::find(issuers.begin(), issuers.end(), b1_2_) !=
+              issuers.end());
+}
+
+// Searching for the issuer of a self-issued cert returns the same cert if it
+// happens to be in the CertSourceStatic.
+// Conceptually this makes sense, though probably not very useful in practice.
+// Doesn't hurt anything though.
+TEST_F(CertSourceStaticTest, SelfIssued) {
+  CertSourceStatic source;
+  AddAllCerts(&source);
+
+  std::vector<scoped_refptr<ParsedCertificate>> issuers;
+  source.SyncGetIssuersOf(root_.get(), &issuers);
+
+  ASSERT_EQ(1U, issuers.size());
+  EXPECT_TRUE(issuers[0] == root_);
+}
+
+// CertSourceStatic never returns results asynchronously.
+TEST_F(CertSourceStaticTest, IsNotAsync) {
+  CertSourceStatic source;
+  source.AddCert(b1_1_);
+  std::unique_ptr<CertSource::Request> request;
+  source.AsyncGetIssuersOf(c1_1_.get(), base::Bind(&NotCalled), &request);
+  EXPECT_EQ(nullptr, request);
+}
+
+}  // namespace
+
+}  // namespace net