Change Origin bound certs -> Domain bound certs.

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 374 matching lines @@
   SSLClientSocket::NextProto protocol = default_protocol_;
   if (is_secure_) {
     SSLClientSocket* ssl_socket = GetSSLClientSocket();
 
     SSLClientSocket::NextProto protocol_negotiated =
         ssl_socket->protocol_negotiated();
     if (protocol_negotiated != SSLClientSocket::kProtoUnknown) {
       protocol = protocol_negotiated;
     }
 
-    if (ssl_socket->WasOriginBoundCertSent()) {
+    if (ssl_socket->WasDomainBoundCertSent()) {
       // According to the SPDY spec, the credential associated with the TLS
       // connection is stored in slot[0].
       credential_state_.SetHasCredential(host_port_pair());
     }
   }
 
   DCHECK(protocol >= SSLClientSocket::kProtoSPDY2);
   DCHECK(protocol <= SSLClientSocket::kProtoSPDY3);
   int version = (protocol == SSLClientSocket::kProtoSPDY3) ? 3 : 2;
   flow_control_ = (protocol >= SSLClientSocket::kProtoSPDY21);
@@ skipping 171 matching lines @@
   DCHECK_EQ(active_streams_[stream_id].get(), stream.get());
   return OK;
 }
 
 bool SpdySession::NeedsCredentials(const HostPortPair& origin) const {
   if (!is_secure_)
     return false;
   SSLClientSocket* ssl_socket = GetSSLClientSocket();
   if (ssl_socket->protocol_negotiated() < SSLClientSocket::kProtoSPDY3)
     return false;
-  if (!ssl_socket->WasOriginBoundCertSent())
+  if (!ssl_socket->WasDomainBoundCertSent())
     return false;
   return !credential_state_.HasCredential(origin);
 }
 
 void SpdySession::AddPooledAlias(const HostPortProxyPair& alias) {
   pooled_aliases_.insert(alias);
 }
 
 int SpdySession::WriteSynStream(
     spdy::SpdyStreamId stream_id,
@@ skipping 56 matching lines @@
 
   std::vector<uint8> proof;
   switch (type) {
     case CLIENT_CERT_ECDSA_SIGN: {
       base::StringPiece spki_piece;
       asn1::ExtractSPKIFromDERCert(cert, &spki_piece);
       std::vector<uint8> spki(spki_piece.data(),
                               spki_piece.data() + spki_piece.size());
       scoped_ptr<crypto::ECPrivateKey> private_key(
           crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
-              OriginBoundCertService::kEPKIPassword, key_data, spki));
+              ServerBoundCertService::kEPKIPassword, key_data, spki));
       scoped_ptr<crypto::ECSignatureCreator> creator(
           crypto::ECSignatureCreator::Create(private_key.get()));
       creator->Sign(secret, arraysize(secret), &proof);
       break;
     }
     default:
       NOTREACHED();
   }
 
   spdy::SpdyCredential credential;
@@ skipping 570 matching lines @@
 }
 
 bool SpdySession::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   if (!is_secure_)
     return false;
   GetSSLClientSocket()->GetSSLCertRequestInfo(cert_request_info);
   return true;
 }
 
-OriginBoundCertService* SpdySession::GetOriginBoundCertService() const {
+ServerBoundCertService* SpdySession::GetServerBoundCertService() const {
   if (!is_secure_)
     return NULL;
-  return GetSSLClientSocket()->GetOriginBoundCertService();
+  return GetSSLClientSocket()->GetServerBoundCertService();
 }
 
-SSLClientCertType SpdySession::GetOriginBoundCertType() const {
+SSLClientCertType SpdySession::GetDomainBoundCertType() const {
   if (!is_secure_)
     return CLIENT_CERT_INVALID_TYPE;
-  return GetSSLClientSocket()->origin_bound_cert_type();
+  return GetSSLClientSocket()->domain_bound_cert_type();
 }
 
 void SpdySession::OnError(int error_code) {
   std::string description = base::StringPrintf(
       "SPDY_ERROR error_code: %d.", error_code);
   CloseSessionOnError(net::ERR_SPDY_PROTOCOL_ERROR, true, description);
 }
 
 void SpdySession::OnStreamError(spdy::SpdyStreamId stream_id,
                                 const std::string& description) {
@@ skipping 659 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net