Change Origin bound certs -> Domain bound certs.

net/socket/socket_test_util.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/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 224 matching lines @@
   reads_.push_back(MockRead(ASYNC, data, length));
 }
 
 SSLSocketDataProvider::SSLSocketDataProvider(IoMode mode, int result)
     : connect(mode, result),
       next_proto_status(SSLClientSocket::kNextProtoUnsupported),
       was_npn_negotiated(false),
       protocol_negotiated(SSLClientSocket::kProtoUnknown),
       client_cert_sent(false),
       cert_request_info(NULL),
-      origin_bound_cert_type(CLIENT_CERT_INVALID_TYPE) {
+      domain_bound_cert_type(CLIENT_CERT_INVALID_TYPE) {
 }
 
 SSLSocketDataProvider::~SSLSocketDataProvider() {
 }
 
 void SSLSocketDataProvider::SetNextProto(SSLClientSocket::NextProto proto) {
   was_npn_negotiated = true;
   next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   protocol_negotiated = proto;
   next_proto = SSLClientSocket::NextProtoToString(proto);
@@ skipping 432 matching lines @@
 }
 
 int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label,
                                            const base::StringPiece& context,
                                            unsigned char *out,
                                            unsigned int outlen) {
   memset(out, 'A', outlen);
   return OK;
 }
 
-OriginBoundCertService* MockClientSocket::GetOriginBoundCertService() const {
+ServerBoundCertService* MockClientSocket::GetServerBoundCertService() const {
   NOTREACHED();
   return NULL;
 }
 
 SSLClientSocket::NextProtoStatus
 MockClientSocket::GetNextProto(std::string* proto, std::string* server_protos) {
   proto->clear();
   server_protos->clear();
   return SSLClientSocket::kNextProtoUnsupported;
 }
@@ skipping 415 matching lines @@
   return -1;
 }
 
 base::TimeDelta MockSSLClientSocket::GetConnectTimeMicros() const {
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
 void MockSSLClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   ssl_info->Reset();
   ssl_info->cert = data_->cert;
-  ssl_info->client_cert_sent = WasOriginBoundCertSent() ||
+  ssl_info->client_cert_sent = WasDomainBoundCertSent() ||
       data_->client_cert_sent;
 }
 
 void MockSSLClientSocket::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(cert_request_info);
   if (data_->cert_request_info) {
     cert_request_info->host_and_port =
         data_->cert_request_info->host_and_port;
     cert_request_info->client_certs = data_->cert_request_info->client_certs;
@@ skipping 25 matching lines @@
     return protocol_negotiated_;
   return data_->protocol_negotiated;
 }
 
 void MockSSLClientSocket::set_protocol_negotiated(
     SSLClientSocket::NextProto protocol_negotiated) {
   is_protocol_negotiated_set_ = true;
   protocol_negotiated_ = protocol_negotiated;
 }
 
-bool MockSSLClientSocket::WasOriginBoundCertSent() const {
-  return data_->origin_bound_cert_type != CLIENT_CERT_INVALID_TYPE;
+bool MockSSLClientSocket::WasDomainBoundCertSent() const {
+  return data_->domain_bound_cert_type != CLIENT_CERT_INVALID_TYPE;
 }
 
-SSLClientCertType MockSSLClientSocket::origin_bound_cert_type() const {
-  return data_->origin_bound_cert_type;
+SSLClientCertType MockSSLClientSocket::domain_bound_cert_type() const {
+  return data_->domain_bound_cert_type;
 }
 
-SSLClientCertType MockSSLClientSocket::set_origin_bound_cert_type(
+SSLClientCertType MockSSLClientSocket::set_domain_bound_cert_type(
     SSLClientCertType type) {
-  return data_->origin_bound_cert_type = type;
+  return data_->domain_bound_cert_type = type;
 }
 
-OriginBoundCertService* MockSSLClientSocket::GetOriginBoundCertService() const {
-  return data_->origin_bound_cert_service;
+ServerBoundCertService* MockSSLClientSocket::GetServerBoundCertService() const {
+  return data_->server_bound_cert_service;
 }
 
 void MockSSLClientSocket::OnReadComplete(const MockRead& data) {
   NOTIMPLEMENTED();
 }
 
 MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data,
                                          net::NetLog* net_log)
     : connected_(false),
       data_(data),
@@ skipping 414 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net