Fix PathBuilderKeyRolloverTest.TestMultipleRootMatchesOnlyOneWorks unordered_multimap ordering depe…

net/cert/internal/path_builder_unittest.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/path_builder.h"
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "net/cert/internal/cert_issuer_source_static.h"
 #include "net/cert/internal/parsed_certificate.h"
 #include "net/cert/internal/signature_policy.h"
 #include "net/cert/internal/test_helpers.h"
+#include "net/cert/internal/trust_store_collection.h"
 #include "net/cert/internal/trust_store_in_memory.h"
 #include "net/cert/internal/verify_certificate_chain.h"
 #include "net/cert/pem_tokenizer.h"
 #include "net/der/input.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_certificate_data.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 561 matching lines @@
 
   EXPECT_FALSE(result.HasValidPath());
 
   ASSERT_EQ(0U, result.paths.size());
 }
 
 // Tests that multiple trust root matches on a single path will be considered.
 // Both roots have the same subject but different keys. Only one of them will
 // verify.
 TEST_F(PathBuilderKeyRolloverTest, TestMultipleRootMatchesOnlyOneWorks) {
-  TrustStoreInMemory trust_store;
+  TrustStoreCollection trust_store_collection;
+  TrustStoreInMemory trust_store1;
+  TrustStoreInMemory trust_store2;
+  trust_store_collection.AddTrustStore(&trust_store1);
+  trust_store_collection.AddTrustStore(&trust_store2);
   // Add two trust anchors (newroot_ and oldroot_). Path building will attempt
-  // them in this same order.
-  trust_store.AddTrustAnchor(
+  // them in this same order, as trust_store1 was added to
+  // trust_store_collection first.
+  trust_store1.AddTrustAnchor(
       TrustAnchor::CreateFromCertificateNoConstraints(newroot_));
-  trust_store.AddTrustAnchor(oldroot_);
+  trust_store2.AddTrustAnchor(oldroot_);
 
   // Only oldintermediate is supplied, so the path with newroot should fail,
   // oldroot should succeed.
   CertIssuerSourceStatic sync_certs;
   sync_certs.AddCert(oldintermediate_);
 
   CertPathBuilder::Result result;
-  CertPathBuilder path_builder(target_, &trust_store, &signature_policy_, time_,
-                               &result);
+  CertPathBuilder path_builder(target_, &trust_store_collection,
+                               &signature_policy_, time_, &result);
   path_builder.AddCertIssuerSource(&sync_certs);
 
   path_builder.Run();
 
   EXPECT_TRUE(result.HasValidPath());
   ASSERT_EQ(2U, result.paths.size());
 
   {
     // Path builder may first attempt: target <- oldintermediate <- newroot
     // but it will fail since oldintermediate is signed by oldroot.
@@ skipping 504 matching lines @@
   EXPECT_EQ(target_, path1.certs[0]);
   EXPECT_EQ(newintermediate_, path1.certs[1]);
   EXPECT_EQ(newroot_, path1.trust_anchor->cert());
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace net