Rename ServerBoundCert => ChannelID to reflect the current name

net/ssl/channel_id_service_unittest.cc

Index: net/ssl/channel_id_service_unittest.cc
diff --git a/net/ssl/server_bound_cert_service_unittest.cc b/net/ssl/channel_id_service_unittest.cc
similarity index 63%
rename from net/ssl/server_bound_cert_service_unittest.cc
rename to net/ssl/channel_id_service_unittest.cc
index 2be073bb16c3b930dda083c631a3116970eab6b8..8cf30dd859bfa32bea2a3ae9dd98f3dd802c427a 100644
--- a/net/ssl/server_bound_cert_service_unittest.cc
+++ b/net/ssl/channel_id_service_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/ssl/server_bound_cert_service.h"
+#include "net/ssl/channel_id_service.h"
 
 #include <string>
 #include <vector>
@@ -17,7 +17,7 @@
 #include "net/base/test_completion_callback.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/x509_certificate.h"
-#include "net/ssl/default_server_bound_cert_store.h"
+#include "net/ssl/default_channel_id_store.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -50,63 +50,63 @@ class FailingTaskRunner : public base::TaskRunner {
   DISALLOW_COPY_AND_ASSIGN(FailingTaskRunner);
 };
 
-class MockServerBoundCertStoreWithAsyncGet
-    : public DefaultServerBoundCertStore {
+class MockChannelIDStoreWithAsyncGet
+    : public DefaultChannelIDStore {
  public:
-  MockServerBoundCertStoreWithAsyncGet()
-      : DefaultServerBoundCertStore(NULL), cert_count_(0) {}
-
-  virtual int GetServerBoundCert(const std::string& server_identifier,
-                                 base::Time* expiration_time,
-                                 std::string* private_key_result,
-                                 std::string* cert_result,
-                                 const GetCertCallback& callback) OVERRIDE;
-
-  virtual void SetServerBoundCert(const std::string& server_identifier,
-                                  base::Time creation_time,
-                                  base::Time expiration_time,
-                                  const std::string& private_key,
-                                  const std::string& cert) OVERRIDE {
-    cert_count_ = 1;
+  MockChannelIDStoreWithAsyncGet()
+      : DefaultChannelIDStore(NULL), channel_id_count_(0) {}
+
+  virtual int GetChannelID(const std::string& server_identifier,
+                           base::Time* expiration_time,
+                           std::string* private_key_result,
+                           std::string* cert_result,
+                           const GetChannelIDCallback& callback) OVERRIDE;
+
+  virtual void SetChannelID(const std::string& server_identifier,
+                            base::Time creation_time,
+                            base::Time expiration_time,
+                            const std::string& private_key,
+                            const std::string& cert) OVERRIDE {
+    channel_id_count_ = 1;
   }
 
-  virtual int GetCertCount() OVERRIDE { return cert_count_; }
+  virtual int GetChannelIDCount() OVERRIDE { return channel_id_count_; }
 
-  void CallGetServerBoundCertCallbackWithResult(int err,
-                                                base::Time expiration_time,
-                                                const std::string& private_key,
-                                                const std::string& cert);
+  void CallGetChannelIDCallbackWithResult(int err,
+                                          base::Time expiration_time,
+                                          const std::string& private_key,
+                                          const std::string& cert);
 
  private:
-  GetCertCallback callback_;
+  GetChannelIDCallback callback_;
   std::string server_identifier_;
-  int cert_count_;
+  int channel_id_count_;
 };
 
-int MockServerBoundCertStoreWithAsyncGet::GetServerBoundCert(
+int MockChannelIDStoreWithAsyncGet::GetChannelID(
     const std::string& server_identifier,
     base::Time* expiration_time,
     std::string* private_key_result,
     std::string* cert_result,
-    const GetCertCallback& callback) {
+    const GetChannelIDCallback& callback) {
   server_identifier_ = server_identifier;
   callback_ = callback;
-  // Reset the cert count, it'll get incremented in either SetServerBoundCert or
-  // CallGetServerBoundCertCallbackWithResult.
-  cert_count_ = 0;
+  // Reset the cert count, it'll get incremented in either SetChannelID or
+  // CallGetChannelIDCallbackWithResult.
+  channel_id_count_ = 0;
   // Do nothing else: the results to be provided will be specified through
-  // CallGetServerBoundCertCallbackWithResult.
+  // CallGetChannelIDCallbackWithResult.
   return ERR_IO_PENDING;
 }
 
 void
-MockServerBoundCertStoreWithAsyncGet::CallGetServerBoundCertCallbackWithResult(
+MockChannelIDStoreWithAsyncGet::CallGetChannelIDCallbackWithResult(
     int err,
     base::Time expiration_time,
     const std::string& private_key,
     const std::string& cert) {
   if (err == OK)
-    cert_count_ = 1;
+    channel_id_count_ = 1;
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::Bind(callback_,
                                                     err,
@@ -116,48 +116,48 @@ MockServerBoundCertStoreWithAsyncGet::CallGetServerBoundCertCallbackWithResult(
                                                     cert));
 }
 
-class ServerBoundCertServiceTest : public testing::Test {
+class ChannelIDServiceTest : public testing::Test {
  public:
-  ServerBoundCertServiceTest()
-      : service_(new ServerBoundCertService(
-            new DefaultServerBoundCertStore(NULL),
+  ChannelIDServiceTest()
+      : service_(new ChannelIDService(
+            new DefaultChannelIDStore(NULL),
             base::MessageLoopProxy::current())) {
   }
 
  protected:
-  scoped_ptr<ServerBoundCertService> service_;
+  scoped_ptr<ChannelIDService> service_;
 };
 
-TEST_F(ServerBoundCertServiceTest, GetDomainForHost) {
+TEST_F(ChannelIDServiceTest, GetDomainForHost) {
   EXPECT_EQ("google.com",
-            ServerBoundCertService::GetDomainForHost("google.com"));
+            ChannelIDService::GetDomainForHost("google.com"));
   EXPECT_EQ("google.com",
-            ServerBoundCertService::GetDomainForHost("www.google.com"));
+            ChannelIDService::GetDomainForHost("www.google.com"));
   EXPECT_EQ("foo.appspot.com",
-            ServerBoundCertService::GetDomainForHost("foo.appspot.com"));
+            ChannelIDService::GetDomainForHost("foo.appspot.com"));
   EXPECT_EQ("bar.appspot.com",
-            ServerBoundCertService::GetDomainForHost("foo.bar.appspot.com"));
+            ChannelIDService::GetDomainForHost("foo.bar.appspot.com"));
   EXPECT_EQ("appspot.com",
-            ServerBoundCertService::GetDomainForHost("appspot.com"));
+            ChannelIDService::GetDomainForHost("appspot.com"));
   EXPECT_EQ("google.com",
-            ServerBoundCertService::GetDomainForHost("www.mail.google.com"));
+            ChannelIDService::GetDomainForHost("www.mail.google.com"));
   EXPECT_EQ("goto",
-            ServerBoundCertService::GetDomainForHost("goto"));
+            ChannelIDService::GetDomainForHost("goto"));
   EXPECT_EQ("127.0.0.1",
-            ServerBoundCertService::GetDomainForHost("127.0.0.1"));
+            ChannelIDService::GetDomainForHost("127.0.0.1"));
 }
 
-TEST_F(ServerBoundCertServiceTest, GetCacheMiss) {
+TEST_F(ChannelIDServiceTest, GetCacheMiss) {
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   // Synchronous completion, because the store is initialized.
   std::string private_key, der_cert;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetDomainBoundCert(
+  error = service_->GetChannelID(
       host, &private_key, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_FILE_NOT_FOUND, error);
   EXPECT_FALSE(request_handle.is_active());
@@ -165,17 +165,17 @@ TEST_F(ServerBoundCertServiceTest, GetCacheMiss) {
   EXPECT_TRUE(der_cert.empty());
 }
 
-TEST_F(ServerBoundCertServiceTest, CacheHit) {
+TEST_F(ChannelIDServiceTest, CacheHit) {
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion.
   std::string private_key_info1, der_cert1;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info1, &der_cert1,
       callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
@@ -189,7 +189,7 @@ TEST_F(ServerBoundCertServiceTest, CacheHit) {
 
   // Synchronous completion.
   std::string private_key_info2, der_cert2;
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info2, &der_cert2,
       callback.callback(), &request_handle);
   EXPECT_FALSE(request_handle.is_active());
@@ -200,7 +200,7 @@ TEST_F(ServerBoundCertServiceTest, CacheHit) {
 
   // Synchronous get.
   std::string private_key_info3, der_cert3;
-  error = service_->GetDomainBoundCert(
+  error = service_->GetChannelID(
       host, &private_key_info3, &der_cert3, callback.callback(),
       &request_handle);
   EXPECT_FALSE(request_handle.is_active());
@@ -214,15 +214,15 @@ TEST_F(ServerBoundCertServiceTest, CacheHit) {
   EXPECT_EQ(0u, service_->inflight_joins());
 }
 
-TEST_F(ServerBoundCertServiceTest, StoreCerts) {
+TEST_F(ChannelIDServiceTest, StoreChannelIDs) {
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   std::string host1("encrypted.google.com");
   std::string private_key_info1, der_cert1;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host1, &private_key_info1, &der_cert1,
       callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
@@ -233,7 +233,7 @@ TEST_F(ServerBoundCertServiceTest, StoreCerts) {
 
   std::string host2("www.verisign.com");
   std::string private_key_info2, der_cert2;
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host2, &private_key_info2, &der_cert2,
       callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
@@ -244,7 +244,7 @@ TEST_F(ServerBoundCertServiceTest, StoreCerts) {
 
   std::string host3("www.twitter.com");
   std::string private_key_info3, der_cert3;
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host3, &private_key_info3, &der_cert3,
       callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
@@ -262,25 +262,25 @@ TEST_F(ServerBoundCertServiceTest, StoreCerts) {
 }
 
 // Tests an inflight join.
-TEST_F(ServerBoundCertServiceTest, InflightJoin) {
+TEST_F(ChannelIDServiceTest, InflightJoin) {
   std::string host("encrypted.google.com");
   int error;
 
   std::string private_key_info1, der_cert1;
   TestCompletionCallback callback1;
-  ServerBoundCertService::RequestHandle request_handle1;
+  ChannelIDService::RequestHandle request_handle1;
 
   std::string private_key_info2, der_cert2;
   TestCompletionCallback callback2;
-  ServerBoundCertService::RequestHandle request_handle2;
+  ChannelIDService::RequestHandle request_handle2;
 
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info1, &der_cert1,
       callback1.callback(), &request_handle1);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle1.is_active());
   // Should join with the original request.
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info2, &der_cert2,
       callback2.callback(), &request_handle2);
   EXPECT_EQ(ERR_IO_PENDING, error);
@@ -298,26 +298,26 @@ TEST_F(ServerBoundCertServiceTest, InflightJoin) {
 }
 
 // Tests an inflight join of a Get request to a GetOrCreate request.
-TEST_F(ServerBoundCertServiceTest, InflightJoinGetOrCreateAndGet) {
+TEST_F(ChannelIDServiceTest, InflightJoinGetOrCreateAndGet) {
   std::string host("encrypted.google.com");
   int error;
 
   std::string private_key_info1, der_cert1;
   TestCompletionCallback callback1;
-  ServerBoundCertService::RequestHandle request_handle1;
+  ChannelIDService::RequestHandle request_handle1;
 
   std::string private_key_info2;
   std::string der_cert2;
   TestCompletionCallback callback2;
-  ServerBoundCertService::RequestHandle request_handle2;
+  ChannelIDService::RequestHandle request_handle2;
 
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info1, &der_cert1,
       callback1.callback(), &request_handle1);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle1.is_active());
   // Should join with the original request.
-  error = service_->GetDomainBoundCert(
+  error = service_->GetChannelID(
       host, &private_key_info2, &der_cert2, callback2.callback(),
       &request_handle2);
   EXPECT_EQ(ERR_IO_PENDING, error);
@@ -335,14 +335,14 @@ TEST_F(ServerBoundCertServiceTest, InflightJoinGetOrCreateAndGet) {
   EXPECT_EQ(1u, service_->workers_created());
 }
 
-TEST_F(ServerBoundCertServiceTest, ExtractValuesFromBytesEC) {
+TEST_F(ChannelIDServiceTest, ExtractValuesFromBytesEC) {
   std::string host("encrypted.google.com");
   std::string private_key_info, der_cert;
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info, &der_cert, callback.callback(),
       &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
@@ -360,7 +360,7 @@ TEST_F(ServerBoundCertServiceTest, ExtractValuesFromBytesEC) {
   std::vector<uint8> key_vec(private_key_info.begin(), private_key_info.end());
   scoped_ptr<crypto::ECPrivateKey> private_key(
       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
-          ServerBoundCertService::kEPKIPassword, key_vec, spki));
+          ChannelIDService::kEPKIPassword, key_vec, spki));
   EXPECT_TRUE(private_key != NULL);
 
   // Check that we can retrieve the cert from the bytes.
@@ -370,24 +370,24 @@ TEST_F(ServerBoundCertServiceTest, ExtractValuesFromBytesEC) {
 }
 
 // Tests that the callback of a canceled request is never made.
-TEST_F(ServerBoundCertServiceTest, CancelRequest) {
+TEST_F(ChannelIDServiceTest, CancelRequest) {
   std::string host("encrypted.google.com");
   std::string private_key_info, der_cert;
   int error;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
-  error = service_->GetOrCreateDomainBoundCert(host,
-                                               &private_key_info,
-                                               &der_cert,
-                                               base::Bind(&FailTest),
-                                               &request_handle);
+  error = service_->GetOrCreateChannelID(host,
+                                         &private_key_info,
+                                         &der_cert,
+                                         base::Bind(&FailTest),
+                                         &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
   request_handle.Cancel();
   EXPECT_FALSE(request_handle.is_active());
 
-  // Wait for reply from ServerBoundCertServiceWorker to be posted back to the
-  // ServerBoundCertService.
+  // Wait for reply from ChannelIDServiceWorker to be posted back to the
+  // ChannelIDService.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Even though the original request was cancelled, the service will still
@@ -396,24 +396,24 @@ TEST_F(ServerBoundCertServiceTest, CancelRequest) {
 }
 
 // Tests that destructing the RequestHandle cancels the request.
-TEST_F(ServerBoundCertServiceTest, CancelRequestByHandleDestruction) {
+TEST_F(ChannelIDServiceTest, CancelRequestByHandleDestruction) {
   std::string host("encrypted.google.com");
   std::string private_key_info, der_cert;
   int error;
   {
-    ServerBoundCertService::RequestHandle request_handle;
+    ChannelIDService::RequestHandle request_handle;
 
-    error = service_->GetOrCreateDomainBoundCert(host,
-                                                 &private_key_info,
-                                                 &der_cert,
-                                                 base::Bind(&FailTest),
-                                                 &request_handle);
+    error = service_->GetOrCreateChannelID(host,
+                                           &private_key_info,
+                                           &der_cert,
+                                           base::Bind(&FailTest),
+                                           &request_handle);
     EXPECT_EQ(ERR_IO_PENDING, error);
     EXPECT_TRUE(request_handle.is_active());
   }
 
-  // Wait for reply from ServerBoundCertServiceWorker to be posted back to the
-  // ServerBoundCertService.
+  // Wait for reply from ChannelIDServiceWorker to be posted back to the
+  // ChannelIDService.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Even though the original request was cancelled, the service will still
@@ -421,26 +421,26 @@ TEST_F(ServerBoundCertServiceTest, CancelRequestByHandleDestruction) {
   EXPECT_EQ(1, service_->cert_count());
 }
 
-TEST_F(ServerBoundCertServiceTest, DestructionWithPendingRequest) {
+TEST_F(ChannelIDServiceTest, DestructionWithPendingRequest) {
   std::string host("encrypted.google.com");
   std::string private_key_info, der_cert;
   int error;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
-  error = service_->GetOrCreateDomainBoundCert(host,
-                                               &private_key_info,
-                                               &der_cert,
-                                               base::Bind(&FailTest),
-                                               &request_handle);
+  error = service_->GetOrCreateChannelID(host,
+                                         &private_key_info,
+                                         &der_cert,
+                                         base::Bind(&FailTest),
+                                         &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
 
-  // Cancel request and destroy the ServerBoundCertService.
+  // Cancel request and destroy the ChannelIDService.
   request_handle.Cancel();
   service_.reset();
 
-  // ServerBoundCertServiceWorker should not post anything back to the
-  // non-existent ServerBoundCertService, but run the loop just to be sure it
+  // ChannelIDServiceWorker should not post anything back to the
+  // non-existent ChannelIDService, but run the loop just to be sure it
   // doesn't.
   base::MessageLoop::current()->RunUntilIdle();
 
@@ -450,67 +450,67 @@ TEST_F(ServerBoundCertServiceTest, DestructionWithPendingRequest) {
 // Tests that shutting down the sequenced worker pool and then making new
 // requests gracefully fails.
 // This is a regression test for http://crbug.com/236387
-TEST_F(ServerBoundCertServiceTest, RequestAfterPoolShutdown) {
+TEST_F(ChannelIDServiceTest, RequestAfterPoolShutdown) {
   scoped_refptr<FailingTaskRunner> task_runner(new FailingTaskRunner);
-  service_.reset(new ServerBoundCertService(
-      new DefaultServerBoundCertStore(NULL), task_runner));
+  service_.reset(new ChannelIDService(
+      new DefaultChannelIDStore(NULL), task_runner));
 
   // Make a request that will force synchronous completion.
   std::string host("encrypted.google.com");
   std::string private_key_info, der_cert;
   int error;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
-  error = service_->GetOrCreateDomainBoundCert(host,
-                                               &private_key_info,
-                                               &der_cert,
-                                               base::Bind(&FailTest),
-                                               &request_handle);
+  error = service_->GetOrCreateChannelID(host,
+                                         &private_key_info,
+                                         &der_cert,
+                                         base::Bind(&FailTest),
+                                         &request_handle);
   // If we got here without crashing or a valgrind error, it worked.
   ASSERT_EQ(ERR_INSUFFICIENT_RESOURCES, error);
   EXPECT_FALSE(request_handle.is_active());
 }
 
 // Tests that simultaneous creation of different certs works.
-TEST_F(ServerBoundCertServiceTest, SimultaneousCreation) {
+TEST_F(ChannelIDServiceTest, SimultaneousCreation) {
   int error;
 
   std::string host1("encrypted.google.com");
   std::string private_key_info1, der_cert1;
   TestCompletionCallback callback1;
-  ServerBoundCertService::RequestHandle request_handle1;
+  ChannelIDService::RequestHandle request_handle1;
 
   std::string host2("foo.com");
   std::string private_key_info2, der_cert2;
   TestCompletionCallback callback2;
-  ServerBoundCertService::RequestHandle request_handle2;
+  ChannelIDService::RequestHandle request_handle2;
 
   std::string host3("bar.com");
   std::string private_key_info3, der_cert3;
   TestCompletionCallback callback3;
-  ServerBoundCertService::RequestHandle request_handle3;
+  ChannelIDService::RequestHandle request_handle3;
 
-  error = service_->GetOrCreateDomainBoundCert(host1,
-                                               &private_key_info1,
-                                               &der_cert1,
-                                               callback1.callback(),
-                                               &request_handle1);
+  error = service_->GetOrCreateChannelID(host1,
+                                         &private_key_info1,
+                                         &der_cert1,
+                                         callback1.callback(),
+                                         &request_handle1);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle1.is_active());
 
-  error = service_->GetOrCreateDomainBoundCert(host2,
-                                               &private_key_info2,
-                                               &der_cert2,
-                                               callback2.callback(),
-                                               &request_handle2);
+  error = service_->GetOrCreateChannelID(host2,
+                                         &private_key_info2,
+                                         &der_cert2,
+                                         callback2.callback(),
+                                         &request_handle2);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle2.is_active());
 
-  error = service_->GetOrCreateDomainBoundCert(host3,
-                                               &private_key_info3,
-                                               &der_cert3,
-                                               callback3.callback(),
-                                               &request_handle3);
+  error = service_->GetOrCreateChannelID(host3,
+                                         &private_key_info3,
+                                         &der_cert3,
+                                         callback3.callback(),
+                                         &request_handle3);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle3.is_active());
 
@@ -541,28 +541,28 @@ TEST_F(ServerBoundCertServiceTest, SimultaneousCreation) {
   EXPECT_EQ(3, service_->cert_count());
 }
 
-TEST_F(ServerBoundCertServiceTest, Expiration) {
-  ServerBoundCertStore* store = service_->GetCertStore();
+TEST_F(ChannelIDServiceTest, Expiration) {
+  ChannelIDStore* store = service_->GetChannelIDStore();
   base::Time now = base::Time::Now();
-  store->SetServerBoundCert("good",
-                            now,
-                            now + base::TimeDelta::FromDays(1),
-                            "a",
-                            "b");
-  store->SetServerBoundCert("expired",
-                            now - base::TimeDelta::FromDays(2),
-                            now - base::TimeDelta::FromDays(1),
-                            "c",
-                            "d");
+  store->SetChannelID("good",
+                      now,
+                      now + base::TimeDelta::FromDays(1),
+                      "a",
+                      "b");
+  store->SetChannelID("expired",
+                      now - base::TimeDelta::FromDays(2),
+                      now - base::TimeDelta::FromDays(1),
+                      "c",
+                      "d");
   EXPECT_EQ(2, service_->cert_count());
 
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   // Cert is valid - synchronous completion.
   std::string private_key_info1, der_cert1;
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       "good", &private_key_info1, &der_cert1,
       callback.callback(), &request_handle);
   EXPECT_EQ(OK, error);
@@ -573,7 +573,7 @@ TEST_F(ServerBoundCertServiceTest, Expiration) {
 
   // Expired cert is valid as well - synchronous completion.
   std::string private_key_info2, der_cert2;
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       "expired", &private_key_info2, &der_cert2,
       callback.callback(), &request_handle);
   EXPECT_EQ(OK, error);
@@ -583,27 +583,27 @@ TEST_F(ServerBoundCertServiceTest, Expiration) {
   EXPECT_STREQ("d", der_cert2.c_str());
 }
 
-TEST_F(ServerBoundCertServiceTest, AsyncStoreGetOrCreateNoCertsInStore) {
-  MockServerBoundCertStoreWithAsyncGet* mock_store =
-      new MockServerBoundCertStoreWithAsyncGet();
-  service_ = scoped_ptr<ServerBoundCertService>(new ServerBoundCertService(
+TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateNoChannelIDsInStore) {
+  MockChannelIDStoreWithAsyncGet* mock_store =
+      new MockChannelIDStoreWithAsyncGet();
+  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
       mock_store, base::MessageLoopProxy::current()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with no certs in the store.
   std::string private_key_info, der_cert;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
 
-  mock_store->CallGetServerBoundCertCallbackWithResult(
+  mock_store->CallGetChannelIDCallbackWithResult(
       ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string());
 
   error = callback.WaitForResult();
@@ -614,27 +614,27 @@ TEST_F(ServerBoundCertServiceTest, AsyncStoreGetOrCreateNoCertsInStore) {
   EXPECT_FALSE(request_handle.is_active());
 }
 
-TEST_F(ServerBoundCertServiceTest, AsyncStoreGetNoCertsInStore) {
-  MockServerBoundCertStoreWithAsyncGet* mock_store =
-      new MockServerBoundCertStoreWithAsyncGet();
-  service_ = scoped_ptr<ServerBoundCertService>(new ServerBoundCertService(
+TEST_F(ChannelIDServiceTest, AsyncStoreGetNoChannelIDsInStore) {
+  MockChannelIDStoreWithAsyncGet* mock_store =
+      new MockChannelIDStoreWithAsyncGet();
+  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
       mock_store, base::MessageLoopProxy::current()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with no certs in the store.
   std::string private_key, der_cert;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetDomainBoundCert(
+  error = service_->GetChannelID(
       host, &private_key, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
 
-  mock_store->CallGetServerBoundCertCallbackWithResult(
+  mock_store->CallGetChannelIDCallbackWithResult(
       ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string());
 
   error = callback.WaitForResult();
@@ -645,27 +645,27 @@ TEST_F(ServerBoundCertServiceTest, AsyncStoreGetNoCertsInStore) {
   EXPECT_FALSE(request_handle.is_active());
 }
 
-TEST_F(ServerBoundCertServiceTest, AsyncStoreGetOrCreateOneCertInStore) {
-  MockServerBoundCertStoreWithAsyncGet* mock_store =
-      new MockServerBoundCertStoreWithAsyncGet();
-  service_ = scoped_ptr<ServerBoundCertService>(new ServerBoundCertService(
+TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateOneCertInStore) {
+  MockChannelIDStoreWithAsyncGet* mock_store =
+      new MockChannelIDStoreWithAsyncGet();
+  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
       mock_store, base::MessageLoopProxy::current()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with a cert in the store.
   std::string private_key_info, der_cert;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key_info, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
 
-  mock_store->CallGetServerBoundCertCallbackWithResult(
+  mock_store->CallGetChannelIDCallbackWithResult(
       OK, base::Time(), "ab", "cd");
 
   error = callback.WaitForResult();
@@ -681,27 +681,27 @@ TEST_F(ServerBoundCertServiceTest, AsyncStoreGetOrCreateOneCertInStore) {
   EXPECT_FALSE(request_handle.is_active());
 }
 
-TEST_F(ServerBoundCertServiceTest, AsyncStoreGetOneCertInStore) {
-  MockServerBoundCertStoreWithAsyncGet* mock_store =
-      new MockServerBoundCertStoreWithAsyncGet();
-  service_ = scoped_ptr<ServerBoundCertService>(new ServerBoundCertService(
+TEST_F(ChannelIDServiceTest, AsyncStoreGetOneCertInStore) {
+  MockChannelIDStoreWithAsyncGet* mock_store =
+      new MockChannelIDStoreWithAsyncGet();
+  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
       mock_store, base::MessageLoopProxy::current()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
-  ServerBoundCertService::RequestHandle request_handle;
+  ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with a cert in the store.
   std::string private_key, der_cert;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetDomainBoundCert(
+  error = service_->GetChannelID(
       host, &private_key, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
 
-  mock_store->CallGetServerBoundCertCallbackWithResult(
+  mock_store->CallGetChannelIDCallbackWithResult(
       OK, base::Time(), "ab", "cd");
 
   error = callback.WaitForResult();
@@ -716,10 +716,10 @@ TEST_F(ServerBoundCertServiceTest, AsyncStoreGetOneCertInStore) {
   EXPECT_FALSE(request_handle.is_active());
 }
 
-TEST_F(ServerBoundCertServiceTest, AsyncStoreGetThenCreateNoCertsInStore) {
-  MockServerBoundCertStoreWithAsyncGet* mock_store =
-      new MockServerBoundCertStoreWithAsyncGet();
-  service_ = scoped_ptr<ServerBoundCertService>(new ServerBoundCertService(
+TEST_F(ChannelIDServiceTest, AsyncStoreGetThenCreateNoCertsInStore) {
+  MockChannelIDStoreWithAsyncGet* mock_store =
+      new MockChannelIDStoreWithAsyncGet();
+  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
       mock_store, base::MessageLoopProxy::current()));
 
   std::string host("encrypted.google.com");
@@ -728,25 +728,25 @@ TEST_F(ServerBoundCertServiceTest, AsyncStoreGetThenCreateNoCertsInStore) {
 
   // Asynchronous get with no certs in the store.
   TestCompletionCallback callback1;
-  ServerBoundCertService::RequestHandle request_handle1;
+  ChannelIDService::RequestHandle request_handle1;
   std::string private_key1, der_cert1;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetDomainBoundCert(
+  error = service_->GetChannelID(
       host, &private_key1, &der_cert1, callback1.callback(), &request_handle1);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle1.is_active());
 
   // Asynchronous get/create with no certs in the store.
   TestCompletionCallback callback2;
-  ServerBoundCertService::RequestHandle request_handle2;
+  ChannelIDService::RequestHandle request_handle2;
   std::string private_key2, der_cert2;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetOrCreateDomainBoundCert(
+  error = service_->GetOrCreateChannelID(
       host, &private_key2, &der_cert2, callback2.callback(), &request_handle2);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle2.is_active());
 
-  mock_store->CallGetServerBoundCertCallbackWithResult(
+  mock_store->CallGetChannelIDCallbackWithResult(
       ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string());
 
   // Even though the first request didn't ask to create a cert, it gets joined