Rename ServerBoundCert => ChannelID to reflect the current name

net/ssl/default_channel_id_store_unittest.cc

 // Copyright (c) 2012 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/ssl/default_server_bound_cert_store.h"
+#include "net/ssl/default_channel_id_store.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 35 matching lines @@
 
   int err_;
   std::string server_identifier_;
   base::Time expiration_time_;
   std::string private_key_;
   std::string cert_;
   bool called_;
 };
 
 void GetAllCallback(
-    ServerBoundCertStore::ServerBoundCertList* dest,
-    const ServerBoundCertStore::ServerBoundCertList& result) {
+    ChannelIDStore::ChannelIDList* dest,
+    const ChannelIDStore::ChannelIDList& result) {
   *dest = result;
 }
 
 class MockPersistentStore
-    : public DefaultServerBoundCertStore::PersistentStore {
+    : public DefaultChannelIDStore::PersistentStore {
  public:
   MockPersistentStore();
 
-  // DefaultServerBoundCertStore::PersistentStore implementation.
+  // DefaultChannelIDStore::PersistentStore implementation.
   virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE;
-  virtual void AddServerBoundCert(
-      const DefaultServerBoundCertStore::ServerBoundCert& cert) OVERRIDE;
-  virtual void DeleteServerBoundCert(
-      const DefaultServerBoundCertStore::ServerBoundCert& cert) OVERRIDE;
+  virtual void AddChannelID(
+      const DefaultChannelIDStore::ChannelID& cert) OVERRIDE;
+  virtual void DeleteChannelID(
+      const DefaultChannelIDStore::ChannelID& cert) OVERRIDE;

[wtc, 2014/07/01 19:50:56]

cert => channel_id

in these two methods.

[Ryan Hamilton, 2014/07/21 19:12:12]

Done.

   virtual void SetForceKeepSessionState() OVERRIDE;
 
  protected:
   virtual ~MockPersistentStore();
 
  private:
-  typedef std::map<std::string, DefaultServerBoundCertStore::ServerBoundCert>
-      ServerBoundCertMap;
+  typedef std::map<std::string, DefaultChannelIDStore::ChannelID>
+      ChannelIDMap;
 
-  ServerBoundCertMap origin_certs_;
+  ChannelIDMap origin_certs_;

[wtc, 2014/07/01 19:50:56]

origin_certs_ => channel_ids_

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

 };
 
 MockPersistentStore::MockPersistentStore() {}
 
 void MockPersistentStore::Load(const LoadedCallback& loaded_callback) {
-  scoped_ptr<ScopedVector<DefaultServerBoundCertStore::ServerBoundCert> >
-      certs(new ScopedVector<DefaultServerBoundCertStore::ServerBoundCert>());
-  ServerBoundCertMap::iterator it;
+  scoped_ptr<ScopedVector<DefaultChannelIDStore::ChannelID> >
+      certs(new ScopedVector<DefaultChannelIDStore::ChannelID>());
+  ChannelIDMap::iterator it;
 
   for (it = origin_certs_.begin(); it != origin_certs_.end(); ++it) {
     certs->push_back(
-        new DefaultServerBoundCertStore::ServerBoundCert(it->second));
+        new DefaultChannelIDStore::ChannelID(it->second));
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(loaded_callback, base::Passed(&certs)));
 }
 
-void MockPersistentStore::AddServerBoundCert(
-    const DefaultServerBoundCertStore::ServerBoundCert& cert) {
+void MockPersistentStore::AddChannelID(
+    const DefaultChannelIDStore::ChannelID& cert) {
   origin_certs_[cert.server_identifier()] = cert;
 }
 
-void MockPersistentStore::DeleteServerBoundCert(
-    const DefaultServerBoundCertStore::ServerBoundCert& cert) {
+void MockPersistentStore::DeleteChannelID(
+    const DefaultChannelIDStore::ChannelID& cert) {

[wtc, 2014/07/01 19:50:56]

cert => channel_id

in these two methods.

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

   origin_certs_.erase(cert.server_identifier());
 }
 
 void MockPersistentStore::SetForceKeepSessionState() {}
 
 MockPersistentStore::~MockPersistentStore() {}
 
 }  // namespace
 
-TEST(DefaultServerBoundCertStoreTest, TestLoading) {
+TEST(DefaultChannelIDStoreTest, TestLoading) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
 
-  persistent_store->AddServerBoundCert(
-      DefaultServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(
+      DefaultChannelIDStore::ChannelID(
           "google.com",
           base::Time(),
           base::Time(),
           "a", "b"));
-  persistent_store->AddServerBoundCert(
-      DefaultServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(
+      DefaultChannelIDStore::ChannelID(
           "verisign.com",
           base::Time(),
           base::Time(),
           "c", "d"));
 
   // Make sure certs load properly.
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
   // Load has not occurred yet.
   EXPECT_EQ(0, store.GetCertCount());
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "verisign.com",
       base::Time(),
       base::Time(),
       "e", "f");
   // Wait for load & queued set task.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2, store.GetCertCount());
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "twitter.com",
       base::Time(),
       base::Time(),
       "g", "h");
   // Set should be synchronous now that load is done.
   EXPECT_EQ(3, store.GetCertCount());
 }
 
 //TODO(mattm): add more tests of without a persistent store?
-TEST(DefaultServerBoundCertStoreTest, TestSettingAndGetting) {
+TEST(DefaultChannelIDStoreTest, TestSettingAndGetting) {
   // No persistent store, all calls will be synchronous.
-  DefaultServerBoundCertStore store(NULL);
+  DefaultChannelIDStore store(NULL);
   base::Time expiration_time;
   std::string private_key, cert;
   EXPECT_EQ(0, store.GetCertCount());
   EXPECT_EQ(ERR_FILE_NOT_FOUND,
-            store.GetServerBoundCert("verisign.com",
+            store.GetChannelID("verisign.com",
                                      &expiration_time,
                                      &private_key,
                                      &cert,
                                      base::Bind(&GetCertCallbackNotCalled)));
   EXPECT_TRUE(private_key.empty());
   EXPECT_TRUE(cert.empty());
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "verisign.com",
       base::Time::FromInternalValue(123),
       base::Time::FromInternalValue(456),
       "i", "j");
   EXPECT_EQ(OK,
-            store.GetServerBoundCert("verisign.com",
+            store.GetChannelID("verisign.com",
                                      &expiration_time,
                                      &private_key,
                                      &cert,
                                      base::Bind(&GetCertCallbackNotCalled)));

[wtc, 2014/07/01 19:50:56]

Fix indentation of the two GetChannelID calls.

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

   EXPECT_EQ(456, expiration_time.ToInternalValue());
   EXPECT_EQ("i", private_key);
   EXPECT_EQ("j", cert);
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestDuplicateCerts) {
+TEST(DefaultChannelIDStoreTest, TestDuplicateCerts) {

[wtc, 2014/07/01 19:50:56]

TestDuplicateCerts => TestDuplicateChannelIDs

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
 
   base::Time expiration_time;
   std::string private_key, cert;
   EXPECT_EQ(0, store.GetCertCount());
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "verisign.com",
       base::Time::FromInternalValue(123),
       base::Time::FromInternalValue(1234),
       "a", "b");
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "verisign.com",
       base::Time::FromInternalValue(456),
       base::Time::FromInternalValue(4567),
       "c", "d");
 
   // Wait for load & queued set tasks.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, store.GetCertCount());
   EXPECT_EQ(OK,
-            store.GetServerBoundCert("verisign.com",
+            store.GetChannelID("verisign.com",
                                      &expiration_time,
                                      &private_key,
                                      &cert,
                                      base::Bind(&GetCertCallbackNotCalled)));

[wtc, 2014/07/01 19:50:56]

Fix the indentation of the arguments.

[Ryan Hamilton, 2014/07/21 19:12:12]

Done.

   EXPECT_EQ(4567, expiration_time.ToInternalValue());
   EXPECT_EQ("c", private_key);
   EXPECT_EQ("d", cert);
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestAsyncGet) {
+TEST(DefaultChannelIDStoreTest, TestAsyncGet) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  persistent_store->AddServerBoundCert(ServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(ChannelIDStore::ChannelID(
       "verisign.com",
       base::Time::FromInternalValue(123),
       base::Time::FromInternalValue(1234),
       "a", "b"));
 
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
   AsyncGetCertHelper helper;
   base::Time expiration_time;
   std::string private_key;
   std::string cert = "not set";
   EXPECT_EQ(0, store.GetCertCount());
   EXPECT_EQ(ERR_IO_PENDING,
-            store.GetServerBoundCert("verisign.com",
+            store.GetChannelID("verisign.com",
                                      &expiration_time,
                                      &private_key,
                                      &cert,
                                      base::Bind(&AsyncGetCertHelper::Callback,
                                                 base::Unretained(&helper))));
 
   // Wait for load & queued get tasks.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, store.GetCertCount());
   EXPECT_EQ("not set", cert);
   EXPECT_TRUE(helper.called_);
   EXPECT_EQ(OK, helper.err_);
   EXPECT_EQ("verisign.com", helper.server_identifier_);
   EXPECT_EQ(1234, helper.expiration_time_.ToInternalValue());
   EXPECT_EQ("a", helper.private_key_);
   EXPECT_EQ("b", helper.cert_);
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestDeleteAll) {
+TEST(DefaultChannelIDStoreTest, TestDeleteAll) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
 
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "verisign.com",
       base::Time(),
       base::Time(),
       "a", "b");
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "google.com",
       base::Time(),
       base::Time(),
       "c", "d");
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "harvard.com",
       base::Time(),
       base::Time(),
       "e", "f");
   // Wait for load & queued set tasks.
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(3, store.GetCertCount());
   int delete_finished = 0;
   store.DeleteAll(base::Bind(&CallCounter, &delete_finished));
   ASSERT_EQ(1, delete_finished);
   EXPECT_EQ(0, store.GetCertCount());
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestAsyncGetAndDeleteAll) {
+TEST(DefaultChannelIDStoreTest, TestAsyncGetAndDeleteAll) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  persistent_store->AddServerBoundCert(ServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(ChannelIDStore::ChannelID(
       "verisign.com",
       base::Time(),
       base::Time(),
       "a", "b"));
-  persistent_store->AddServerBoundCert(ServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(ChannelIDStore::ChannelID(
       "google.com",
       base::Time(),
       base::Time(),
       "c", "d"));
 
-  ServerBoundCertStore::ServerBoundCertList pre_certs;
-  ServerBoundCertStore::ServerBoundCertList post_certs;
+  ChannelIDStore::ChannelIDList pre_certs;
+  ChannelIDStore::ChannelIDList post_certs;

[wtc, 2014/07/01 19:50:56]

pre_certs => pre_channel_ids

post_certs => post_channel_ids

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

   int delete_finished = 0;
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
 
-  store.GetAllServerBoundCerts(base::Bind(GetAllCallback, &pre_certs));
+  store.GetAllChannelIDs(base::Bind(GetAllCallback, &pre_certs));
   store.DeleteAll(base::Bind(&CallCounter, &delete_finished));
-  store.GetAllServerBoundCerts(base::Bind(GetAllCallback, &post_certs));
+  store.GetAllChannelIDs(base::Bind(GetAllCallback, &post_certs));
   // Tasks have not run yet.
   EXPECT_EQ(0u, pre_certs.size());
   // Wait for load & queued tasks.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, store.GetCertCount());
   EXPECT_EQ(2u, pre_certs.size());
   EXPECT_EQ(0u, post_certs.size());
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestDelete) {
+TEST(DefaultChannelIDStoreTest, TestDelete) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
 
   base::Time expiration_time;
   std::string private_key, cert;
   EXPECT_EQ(0, store.GetCertCount());
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "verisign.com",
       base::Time(),
       base::Time(),
       "a", "b");
   // Wait for load & queued set task.
   base::MessageLoop::current()->RunUntilIdle();
 
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "google.com",
       base::Time(),
       base::Time(),
       "c", "d");
 
   EXPECT_EQ(2, store.GetCertCount());
   int delete_finished = 0;
-  store.DeleteServerBoundCert("verisign.com",
+  store.DeleteChannelID("verisign.com",
                               base::Bind(&CallCounter, &delete_finished));
   ASSERT_EQ(1, delete_finished);
   EXPECT_EQ(1, store.GetCertCount());
   EXPECT_EQ(ERR_FILE_NOT_FOUND,
-            store.GetServerBoundCert("verisign.com",
+            store.GetChannelID("verisign.com",
                                      &expiration_time,
                                      &private_key,
                                      &cert,
                                      base::Bind(&GetCertCallbackNotCalled)));
   EXPECT_EQ(OK,
-            store.GetServerBoundCert("google.com",
+            store.GetChannelID("google.com",
                                      &expiration_time,
                                      &private_key,
                                      &cert,
                                      base::Bind(&GetCertCallbackNotCalled)));
   int delete2_finished = 0;
-  store.DeleteServerBoundCert("google.com",
+  store.DeleteChannelID("google.com",
                               base::Bind(&CallCounter, &delete2_finished));
   ASSERT_EQ(1, delete2_finished);
   EXPECT_EQ(0, store.GetCertCount());
   EXPECT_EQ(ERR_FILE_NOT_FOUND,
-            store.GetServerBoundCert("google.com",
+            store.GetChannelID("google.com",
                                      &expiration_time,
                                      &private_key,
                                      &cert,
                                      base::Bind(&GetCertCallbackNotCalled)));

[wtc, 2014/07/01 19:50:56]

Fix the indentation of the three GetChannelID calls.

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

 }
 
-TEST(DefaultServerBoundCertStoreTest, TestAsyncDelete) {
+TEST(DefaultChannelIDStoreTest, TestAsyncDelete) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  persistent_store->AddServerBoundCert(ServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(ChannelIDStore::ChannelID(
       "a.com",
       base::Time::FromInternalValue(1),
       base::Time::FromInternalValue(2),
       "a", "b"));
-  persistent_store->AddServerBoundCert(ServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(ChannelIDStore::ChannelID(
       "b.com",
       base::Time::FromInternalValue(3),
       base::Time::FromInternalValue(4),
       "c", "d"));
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
   int delete_finished = 0;
-  store.DeleteServerBoundCert("a.com",
+  store.DeleteChannelID("a.com",
                               base::Bind(&CallCounter, &delete_finished));

[wtc, 2014/07/01 19:50:56]

Fix the indentation.

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

 
   AsyncGetCertHelper a_helper;
   AsyncGetCertHelper b_helper;
   base::Time expiration_time;
   std::string private_key;
   std::string cert = "not set";
   EXPECT_EQ(0, store.GetCertCount());
   EXPECT_EQ(ERR_IO_PENDING,
-      store.GetServerBoundCert(
+      store.GetChannelID(
           "a.com", &expiration_time, &private_key, &cert,
           base::Bind(&AsyncGetCertHelper::Callback,
                      base::Unretained(&a_helper))));
   EXPECT_EQ(ERR_IO_PENDING,
-      store.GetServerBoundCert(
+      store.GetChannelID(
           "b.com", &expiration_time, &private_key, &cert,
           base::Bind(&AsyncGetCertHelper::Callback,
                      base::Unretained(&b_helper))));
 
   EXPECT_EQ(0, delete_finished);
   EXPECT_FALSE(a_helper.called_);
   EXPECT_FALSE(b_helper.called_);
   // Wait for load & queued tasks.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, delete_finished);
   EXPECT_EQ(1, store.GetCertCount());
   EXPECT_EQ("not set", cert);
   EXPECT_TRUE(a_helper.called_);
   EXPECT_EQ(ERR_FILE_NOT_FOUND, a_helper.err_);
   EXPECT_EQ("a.com", a_helper.server_identifier_);
   EXPECT_EQ(0, a_helper.expiration_time_.ToInternalValue());
   EXPECT_EQ("", a_helper.private_key_);
   EXPECT_EQ("", a_helper.cert_);
   EXPECT_TRUE(b_helper.called_);
   EXPECT_EQ(OK, b_helper.err_);
   EXPECT_EQ("b.com", b_helper.server_identifier_);
   EXPECT_EQ(4, b_helper.expiration_time_.ToInternalValue());
   EXPECT_EQ("c", b_helper.private_key_);
   EXPECT_EQ("d", b_helper.cert_);
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestGetAll) {
+TEST(DefaultChannelIDStoreTest, TestGetAll) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
 
   EXPECT_EQ(0, store.GetCertCount());
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "verisign.com",
       base::Time(),
       base::Time(),
       "a", "b");
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "google.com",
       base::Time(),
       base::Time(),
       "c", "d");
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "harvard.com",
       base::Time(),
       base::Time(),
       "e", "f");
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "mit.com",
       base::Time(),
       base::Time(),
       "g", "h");
   // Wait for load & queued set tasks.
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(4, store.GetCertCount());
-  ServerBoundCertStore::ServerBoundCertList certs;
-  store.GetAllServerBoundCerts(base::Bind(GetAllCallback, &certs));
+  ChannelIDStore::ChannelIDList certs;

[wtc, 2014/07/01 19:50:56]

certs => channel_ids

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

+  store.GetAllChannelIDs(base::Bind(GetAllCallback, &certs));
   EXPECT_EQ(4u, certs.size());
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestInitializeFrom) {
+TEST(DefaultChannelIDStoreTest, TestInitializeFrom) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  DefaultServerBoundCertStore store(persistent_store.get());
+  DefaultChannelIDStore store(persistent_store.get());
 
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "preexisting.com",
       base::Time(),
       base::Time(),
       "a", "b");
-  store.SetServerBoundCert(
+  store.SetChannelID(
       "both.com",
       base::Time(),
       base::Time(),
       "c", "d");
   // Wait for load & queued set tasks.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2, store.GetCertCount());
 
-  ServerBoundCertStore::ServerBoundCertList source_certs;
-  source_certs.push_back(ServerBoundCertStore::ServerBoundCert(
+  ChannelIDStore::ChannelIDList source_certs;

[wtc, 2014/07/01 19:50:56]

source_certs => source_channel_ids

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

+  source_certs.push_back(ChannelIDStore::ChannelID(
       "both.com",
       base::Time(),
       base::Time(),
       // Key differs from above to test that existing entries are overwritten.
       "e", "f"));
-  source_certs.push_back(ServerBoundCertStore::ServerBoundCert(
+  source_certs.push_back(ChannelIDStore::ChannelID(
       "copied.com",
       base::Time(),
       base::Time(),
       "g", "h"));
   store.InitializeFrom(source_certs);
   EXPECT_EQ(3, store.GetCertCount());
 
-  ServerBoundCertStore::ServerBoundCertList certs;
-  store.GetAllServerBoundCerts(base::Bind(GetAllCallback, &certs));
+  ChannelIDStore::ChannelIDList certs;

[wtc, 2014/07/01 19:50:56]

certs => channel_ids

[Ryan Hamilton, 2014/07/21 19:12:13]

Done.

+  store.GetAllChannelIDs(base::Bind(GetAllCallback, &certs));
   ASSERT_EQ(3u, certs.size());
 
-  ServerBoundCertStore::ServerBoundCertList::iterator cert = certs.begin();
+  ChannelIDStore::ChannelIDList::iterator cert = certs.begin();

[wtc, 2014/07/01 19:50:56]

cert => channel_id

If you decide to rename these local variables, make the same changes to the next
unit test.

[Ryan Hamilton, 2014/07/21 19:12:12]

Done.

   EXPECT_EQ("both.com", cert->server_identifier());
   EXPECT_EQ("e", cert->private_key());
 
   ++cert;
   EXPECT_EQ("copied.com", cert->server_identifier());
   EXPECT_EQ("g", cert->private_key());
 
   ++cert;
   EXPECT_EQ("preexisting.com", cert->server_identifier());
   EXPECT_EQ("a", cert->private_key());
 }
 
-TEST(DefaultServerBoundCertStoreTest, TestAsyncInitializeFrom) {
+TEST(DefaultChannelIDStoreTest, TestAsyncInitializeFrom) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
-  persistent_store->AddServerBoundCert(ServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(ChannelIDStore::ChannelID(
       "preexisting.com",
       base::Time(),
       base::Time(),
       "a", "b"));
-  persistent_store->AddServerBoundCert(ServerBoundCertStore::ServerBoundCert(
+  persistent_store->AddChannelID(ChannelIDStore::ChannelID(
       "both.com",
       base::Time(),
       base::Time(),
       "c", "d"));
 
-  DefaultServerBoundCertStore store(persistent_store.get());
-  ServerBoundCertStore::ServerBoundCertList source_certs;
-  source_certs.push_back(ServerBoundCertStore::ServerBoundCert(
+  DefaultChannelIDStore store(persistent_store.get());
+  ChannelIDStore::ChannelIDList source_certs;
+  source_certs.push_back(ChannelIDStore::ChannelID(
       "both.com",
       base::Time(),
       base::Time(),
       // Key differs from above to test that existing entries are overwritten.
       "e", "f"));
-  source_certs.push_back(ServerBoundCertStore::ServerBoundCert(
+  source_certs.push_back(ChannelIDStore::ChannelID(
       "copied.com",
       base::Time(),
       base::Time(),
       "g", "h"));
   store.InitializeFrom(source_certs);
   EXPECT_EQ(0, store.GetCertCount());
   // Wait for load & queued tasks.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3, store.GetCertCount());
 
-  ServerBoundCertStore::ServerBoundCertList certs;
-  store.GetAllServerBoundCerts(base::Bind(GetAllCallback, &certs));
+  ChannelIDStore::ChannelIDList certs;
+  store.GetAllChannelIDs(base::Bind(GetAllCallback, &certs));
   ASSERT_EQ(3u, certs.size());
 
-  ServerBoundCertStore::ServerBoundCertList::iterator cert = certs.begin();
+  ChannelIDStore::ChannelIDList::iterator cert = certs.begin();
   EXPECT_EQ("both.com", cert->server_identifier());
   EXPECT_EQ("e", cert->private_key());
 
   ++cert;
   EXPECT_EQ("copied.com", cert->server_identifier());
   EXPECT_EQ("g", cert->private_key());
 
   ++cert;
   EXPECT_EQ("preexisting.com", cert->server_identifier());
   EXPECT_EQ("a", cert->private_key());
 }
 
 }  // namespace net