Rename ServerBoundCert => ChannelID to reflect the current name

chrome/browser/extensions/api/messaging/message_service.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 "chrome/browser/extensions/api/messaging/message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
@@ skipping 312 matching lines @@
                                                     channel_name,
                                                     include_tls_channel_id);
 
   // If the target requests the TLS channel id, begin the lookup for it.
   // The target might also be a lazy background page, checked next, but the
   // loading of lazy background pages continues asynchronously, so enqueue
   // messages awaiting TLS channel ID first.
   if (include_tls_channel_id) {
     pending_tls_channel_id_channels_[GET_CHANNEL_ID(params->receiver_port_id)]
         = PendingMessagesQueue();
-    property_provider_.GetDomainBoundCert(
+    property_provider_.GetChannelID(
         Profile::FromBrowserContext(context),
         source_url,
-        base::Bind(&MessageService::GotDomainBoundCert,
+        base::Bind(&MessageService::GotChannelID,
                    weak_factory_.GetWeakPtr(),
                    base::Passed(make_scoped_ptr(params))));
     return;
   }
 
   // The target might be a lazy background page. In that case, we have to check
   // if it is loaded and ready, and if not, queue up the task and load the
   // page.
   if (MaybeAddPendingLazyBackgroundPageOpenChannelTask(
           context, target_extension, params)) {
@@ skipping 339 matching lines @@
   lazy_background_task_queue_->AddPendingTask(
       context,
       extension->id(),
       base::Bind(&MessageService::PendingLazyBackgroundPageOpenChannel,
                  weak_factory_.GetWeakPtr(),
                  base::Passed(&scoped_params),
                  params->source->GetID()));
   return true;
 }
 
-void MessageService::GotDomainBoundCert(scoped_ptr<OpenChannelParams> params,
-                                        const std::string& tls_channel_id) {
+void MessageService::GotChannelID(scoped_ptr<OpenChannelParams> params,
+                                  const std::string& tls_channel_id) {
   params->tls_channel_id.assign(tls_channel_id);
   int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
 
   PendingTlsChannelIdMap::iterator pending_for_tls_channel_id =
       pending_tls_channel_id_channels_.find(channel_id);
   if (pending_for_tls_channel_id == pending_tls_channel_id_channels_.end()) {
     NOTREACHED();
     return;
   }
 
@@ skipping 58 matching lines @@
 }
 
 void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
                                           int port_id,
                                           const std::string& error_message) {
   ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
   port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), error_message);
 }
 
 }  // namespace extensions