Rename ServerBoundCert => ChannelID to reflect the current name

chrome/browser/extensions/extension_messages_apitest.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 "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 16 matching lines @@
 #include "content/public/test/browser_test_utils.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/api/runtime.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/value_builder.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/jwk_serializer.h"
 #include "net/dns/mock_host_resolver.h"
-#include "net/ssl/server_bound_cert_service.h"
+#include "net/ssl/channel_id_service.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 namespace extensions {
 namespace {
 
 class MessageSender : public content::NotificationObserver {
  public:
@@ skipping 780 matching lines @@
 class ExternallyConnectableMessagingWithTlsChannelIdTest :
   public ExternallyConnectableMessagingTest {
  public:
   ExternallyConnectableMessagingWithTlsChannelIdTest()
       : tls_channel_id_created_(false, false) {
   }
 
   std::string CreateTlsChannelId() {
     scoped_refptr<net::URLRequestContextGetter> request_context_getter(
         profile()->GetRequestContext());
-  std::string domain_bound_private_key;
-  std::string domain_bound_cert;
-  net::ServerBoundCertService::RequestHandle request_handle;
+  std::string channel_id_private_key;
+  std::string channel_id_cert;
+  net::ChannelIDService::RequestHandle request_handle;
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(
             &ExternallyConnectableMessagingWithTlsChannelIdTest::
                 CreateDomainBoundCertOnIOThread,
             base::Unretained(this),
-            base::Unretained(&domain_bound_private_key),
-            base::Unretained(&domain_bound_cert),
+            base::Unretained(&channel_id_private_key),
+            base::Unretained(&channel_id_cert),
             base::Unretained(&request_handle),
             request_context_getter));
     tls_channel_id_created_.Wait();
     // Create the expected value.
     base::StringPiece spki;
-    net::asn1::ExtractSPKIFromDERCert(domain_bound_cert, &spki);
+    net::asn1::ExtractSPKIFromDERCert(channel_id_cert, &spki);
     base::DictionaryValue jwk_value;
     net::JwkSerializer::ConvertSpkiFromDerToJwk(spki, &jwk_value);
     std::string tls_channel_id_value;
     base::JSONWriter::Write(&jwk_value, &tls_channel_id_value);
     return tls_channel_id_value;
   }
 
  private:
   void CreateDomainBoundCertOnIOThread(
-      std::string* domain_bound_private_key,
-      std::string* domain_bound_cert,
-      net::ServerBoundCertService::RequestHandle* request_handle,
+      std::string* channel_id_private_key,
+      std::string* channel_id_cert,
+      net::ChannelIDService::RequestHandle* request_handle,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    net::ServerBoundCertService* server_bound_cert_service =
+    net::ChannelIDService* channel_id_service =
         request_context_getter->GetURLRequestContext()->
-            server_bound_cert_service();
-    int status = server_bound_cert_service->GetOrCreateDomainBoundCert(
+            channel_id_service();
+    int status = channel_id_service->GetOrCreateChannelID(
         chromium_org_url().host(),
-        domain_bound_private_key,
-        domain_bound_cert,
+        channel_id_private_key,
+        channel_id_cert,
         base::Bind(&ExternallyConnectableMessagingWithTlsChannelIdTest::
                    GotDomainBoundCert,
                    base::Unretained(this)),
         request_handle);
     if (status == net::ERR_IO_PENDING)
       return;
     GotDomainBoundCert(status);
   }
 
   void GotDomainBoundCert(int status) {
@@ skipping 170 matching lines @@
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
             CanConnectAndSendMessagesToMainFrame(invalid));
 }
 
 #endif  // !defined(OS_WIN) - http://crbug.com/350517.
 
 }  // namespace
 
 };  // namespace extensions