Rename ServerBoundCert => ChannelID to reflect the current name

net/socket/ssl_client_socket_openssl.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.
 
 // OpenSSL binding for SSLClientSocket. The class layout and general principle
 // of operation is derived from SSLClientSocketNSS.
 
 #include "net/socket/ssl_client_socket_openssl.h"
 
 #include <errno.h>
@@ skipping 338 matching lines @@
       transport_recv_busy_(false),
       weak_factory_(this),
       pending_read_error_(kNoPendingReadResult),
       transport_read_error_(OK),
       transport_write_error_(OK),
       server_cert_chain_(new PeerCertificateChain(NULL)),
       completed_handshake_(false),
       was_ever_used_(false),
       client_auth_cert_needed_(false),
       cert_verifier_(context.cert_verifier),
-      server_bound_cert_service_(context.server_bound_cert_service),
+      channel_id_service_(context.channel_id_service),
       ssl_(NULL),
       transport_bio_(NULL),
       transport_(transport_socket.Pass()),
       host_and_port_(host_and_port),
       ssl_config_(ssl_config),
       ssl_session_cache_shard_(context.ssl_session_cache_shard),
       trying_cached_session_(false),
       next_handshake_state_(STATE_NONE),
       npn_status_(kNextProtoUnsupported),
       channel_id_xtn_negotiated_(false),
@@ skipping 10 matching lines @@
   cert_request_info->cert_key_types = cert_key_types_;
 }
 
 SSLClientSocket::NextProtoStatus SSLClientSocketOpenSSL::GetNextProto(
     std::string* proto, std::string* server_protos) {
   *proto = npn_proto_;
   *server_protos = server_protos_;
   return npn_status_;
 }
 
-ServerBoundCertService*
-SSLClientSocketOpenSSL::GetServerBoundCertService() const {
-  return server_bound_cert_service_;
+ChannelIDService*
+SSLClientSocketOpenSSL::GetChannelIDService() const {
+  return channel_id_service_;
 }
 
 int SSLClientSocketOpenSSL::ExportKeyingMaterial(
     const base::StringPiece& label,
     bool has_context, const base::StringPiece& context,
     unsigned char* out, unsigned int outlen) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   int rv = SSL_export_keying_material(
       ssl_, out, outlen, label.data(), label.size(),
@@ skipping 161 matching lines @@
   ssl_info->cert = server_cert_verify_result_.verified_cert;
   ssl_info->cert_status = server_cert_verify_result_.cert_status;
   ssl_info->is_issued_by_known_root =
       server_cert_verify_result_.is_issued_by_known_root;
   ssl_info->public_key_hashes =
     server_cert_verify_result_.public_key_hashes;
   ssl_info->client_cert_sent =
       ssl_config_.send_client_cert && ssl_config_.client_cert.get();
   ssl_info->channel_id_sent = WasChannelIDSent();
 
-  RecordChannelIDSupport(server_bound_cert_service_,
+  RecordChannelIDSupport(channel_id_service_,
                          channel_id_xtn_negotiated_,
                          ssl_config_.channel_id_enabled,
                          crypto::ECPrivateKey::IsSupported());
 
   const SSL_CIPHER* cipher = SSL_get_current_cipher(ssl_);
   CHECK(cipher);
   ssl_info->security_bits = SSL_CIPHER_get_bits(cipher, NULL);
 
   ssl_info->connection_status = EncodeSSLConnectionStatus(
       SSL_CIPHER_get_id(cipher), 0 /* no compression */,
@@ skipping 168 matching lines @@
      }
   }
   int rv = SSL_set_cipher_list(ssl_, command.c_str());
   // If this fails (rv = 0) it means there are no ciphers enabled on this SSL.
   // This will almost certainly result in the socket failing to complete the
   // handshake at which point the appropriate error is bubbled up to the client.
   LOG_IF(WARNING, rv != 1) << "SSL_set_cipher_list('" << command << "') "
                               "returned " << rv;
 
   // TLS channel ids.
-  if (IsChannelIDEnabled(ssl_config_, server_bound_cert_service_)) {
+  if (IsChannelIDEnabled(ssl_config_, channel_id_service_)) {
     SSL_enable_tls_channel_id(ssl_);
   }
 
   return OK;
 }
 
 void SSLClientSocketOpenSSL::DoReadCallback(int rv) {
   // Since Run may result in Read being called, clear |user_read_callback_|
   // up front.
   if (rv > 0)
@@ skipping 84 matching lines @@
       net_log_.AddEvent(
           NetLog::TYPE_SSL_HANDSHAKE_ERROR,
           CreateNetLogSSLErrorCallback(net_error, ssl_error));
     }
   }
   return net_error;
 }
 
 int SSLClientSocketOpenSSL::DoChannelIDLookup() {
   GotoState(STATE_CHANNEL_ID_LOOKUP_COMPLETE);
-  return server_bound_cert_service_->GetOrCreateDomainBoundCert(
+  return channel_id_service_->GetOrCreateChannelID(
       host_and_port_.host(),
       &channel_id_private_key_,
       &channel_id_cert_,
       base::Bind(&SSLClientSocketOpenSSL::OnHandshakeIOComplete,
                  base::Unretained(this)),
       &channel_id_request_handle_);
 }
 
 int SSLClientSocketOpenSSL::DoChannelIDLookupComplete(int result) {
   if (result < 0)
     return result;
 
   DCHECK_LT(0u, channel_id_private_key_.size());
   // Decode key.
   std::vector<uint8> encrypted_private_key_info;
   std::vector<uint8> subject_public_key_info;
   encrypted_private_key_info.assign(
       channel_id_private_key_.data(),
       channel_id_private_key_.data() + channel_id_private_key_.size());
   subject_public_key_info.assign(
       channel_id_cert_.data(),
       channel_id_cert_.data() + channel_id_cert_.size());
   scoped_ptr<crypto::ECPrivateKey> ec_private_key(
       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
-          ServerBoundCertService::kEPKIPassword,
+          ChannelIDService::kEPKIPassword,
           encrypted_private_key_info,
           subject_public_key_info));
   if (!ec_private_key) {
     LOG(ERROR) << "Failed to import Channel ID.";
     return ERR_CHANNEL_ID_IMPORT_FAILED;
   }
 
   // Hand the key to OpenSSL. Check for error in case OpenSSL rejects the key
   // type.
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
@@ skipping 602 matching lines @@
   return socket->MaybeReplayTransportError(
       bio, cmd, argp, argi, argl, retvalue);
 }
 
 scoped_refptr<X509Certificate>
 SSLClientSocketOpenSSL::GetUnverifiedServerCertificateChain() const {
   return server_cert_;
 }
 
 }  // namespace net