Change Origin bound certs -> Domain bound certs.

net/spdy/spdy_stream.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_stream.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
@@ skipping 72 matching lines @@
       delegate_(NULL),
       request_time_(base::Time::Now()),
       response_(new spdy::SpdyHeaderBlock),
       io_state_(STATE_NONE),
       response_status_(OK),
       cancelled_(false),
       has_upload_data_(false),
       net_log_(net_log),
       send_bytes_(0),
       recv_bytes_(0),
-      ob_cert_type_(CLIENT_CERT_INVALID_TYPE) {
+      domain_bound_cert_type_(CLIENT_CERT_INVALID_TYPE) {
 }
 
 SpdyStream::~SpdyStream() {
   UpdateHistograms();
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(delegate);
   delegate_ = delegate;
 
@@ skipping 379 matching lines @@
   // STATE_DONE. However, we still want to return IO_PENDING to mimic non-push
   // behavior.
   has_upload_data_ = has_upload_data;
   if (pushed_) {
     send_time_ = base::TimeTicks::Now();
     DCHECK(!has_upload_data_);
     DCHECK(response_received());
     return ERR_IO_PENDING;
   }
   CHECK_EQ(STATE_NONE, io_state_);
-  io_state_ = STATE_GET_ORIGIN_BOUND_CERT;
+  io_state_ = STATE_GET_DOMAIN_BOUND_CERT;
   return DoLoop(OK);
 }
 
 int SpdyStream::WriteStreamData(IOBuffer* data, int length,
                                 spdy::SpdyDataFlags flags) {
   return session_->WriteStreamData(stream_id_, data, length, flags);
 }
 
 bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info,
                             bool* was_npn_negotiated,
@@ skipping 48 matching lines @@
   it = headers->find(host_header);
   if (it != (*headers).end())
     host_port = it->second;
   it = headers->find(path_header);
   if (it != (*headers).end())
     path = it->second;
   std::string url = scheme + "://" + host_port + path;
   return GURL(url);
 }
 
-void SpdyStream::OnGetOriginBoundCertComplete(int result) {
-  DCHECK_EQ(STATE_GET_ORIGIN_BOUND_CERT_COMPLETE, io_state_);
+void SpdyStream::OnGetDomainBoundCertComplete(int result) {
+  DCHECK_EQ(STATE_GET_DOMAIN_BOUND_CERT_COMPLETE, io_state_);
   DoLoop(result);
 }
 
 int SpdyStream::DoLoop(int result) {
   do {
     State state = io_state_;
     io_state_ = STATE_NONE;
     switch (state) {
       // State machine 1: Send headers and body.
-      case STATE_GET_ORIGIN_BOUND_CERT:
+      case STATE_GET_DOMAIN_BOUND_CERT:
         CHECK_EQ(OK, result);
-        result = DoGetOriginBoundCert();
+        result = DoGetDomainBoundCert();
         break;
-      case STATE_GET_ORIGIN_BOUND_CERT_COMPLETE:
-        result = DoGetOriginBoundCertComplete(result);
+      case STATE_GET_DOMAIN_BOUND_CERT_COMPLETE:
+        result = DoGetDomainBoundCertComplete(result);
         break;
-      case STATE_SEND_ORIGIN_BOUND_CERT:
+      case STATE_SEND_DOMAIN_BOUND_CERT:
         CHECK_EQ(OK, result);
-        result = DoSendOriginBoundCert();
+        result = DoSendDomainBoundCert();
         break;
-      case STATE_SEND_ORIGIN_BOUND_CERT_COMPLETE:
-        result = DoSendOriginBoundCertComplete(result);
+      case STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE:
+        result = DoSendDomainBoundCertComplete(result);
         break;
       case STATE_SEND_HEADERS:
         CHECK_EQ(OK, result);
         result = DoSendHeaders();
         break;
       case STATE_SEND_HEADERS_COMPLETE:
         result = DoSendHeadersComplete(result);
         break;
       case STATE_SEND_BODY:
         CHECK_EQ(OK, result);
@@ skipping 32 matching lines @@
       default:
         NOTREACHED() << io_state_;
         break;
     }
   } while (result != ERR_IO_PENDING && io_state_ != STATE_NONE &&
            io_state_ != STATE_OPEN);
 
   return result;
 }
 
-int SpdyStream::DoGetOriginBoundCert() {
+int SpdyStream::DoGetDomainBoundCert() {
   CHECK(request_.get());
   HostPortPair origin(HostPortPair::FromURL(GetUrl()));
   if (!session_->NeedsCredentials(origin)) {
     // Proceed directly to sending headers
     io_state_ = STATE_SEND_HEADERS;
     return OK;
   }
 
-  io_state_ = STATE_GET_ORIGIN_BOUND_CERT_COMPLETE;
-  OriginBoundCertService* obc_service = session_->GetOriginBoundCertService();
-  DCHECK(obc_service != NULL);
+  io_state_ = STATE_GET_DOMAIN_BOUND_CERT_COMPLETE;
+  ServerBoundCertService* sbc_service = session_->GetServerBoundCertService();
+  DCHECK(sbc_service != NULL);
   std::vector<uint8> requested_cert_types;
-  requested_cert_types.push_back(session_->GetOriginBoundCertType());
-  int rv = obc_service->GetOriginBoundCert(
-      GetUrl().GetOrigin().spec(), requested_cert_types, &ob_cert_type_,
-      &ob_private_key_, &ob_cert_,
-      base::Bind(&SpdyStream::OnGetOriginBoundCertComplete,
+  requested_cert_types.push_back(session_->GetDomainBoundCertType());
+  int rv = sbc_service->GetDomainBoundCert(
+      GetUrl().GetOrigin().spec(), requested_cert_types,
+      &domain_bound_cert_type_, &domain_bound_private_key_, &domain_bound_cert_,
+      base::Bind(&SpdyStream::OnGetDomainBoundCertComplete,
                  base::Unretained(this)),
-      &ob_cert_request_handle_);
+      &domain_bound_cert_request_handle_);
   return rv;
 }
 
-int SpdyStream::DoGetOriginBoundCertComplete(int result) {
+int SpdyStream::DoGetDomainBoundCertComplete(int result) {
   if (result != OK)
     return result;
 
-  io_state_ = STATE_SEND_ORIGIN_BOUND_CERT;
+  io_state_ = STATE_SEND_DOMAIN_BOUND_CERT;
   return OK;
 }
 
-int SpdyStream::DoSendOriginBoundCert() {
-  io_state_ = STATE_SEND_ORIGIN_BOUND_CERT_COMPLETE;
+int SpdyStream::DoSendDomainBoundCert() {
+  io_state_ = STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE;
   CHECK(request_.get());
   std::string origin = GetUrl().GetOrigin().spec();
   origin.erase(origin.length() - 1);  // trim trailing slash
   int rv =  session_->WriteCredentialFrame(
-      origin, ob_cert_type_, ob_private_key_, ob_cert_,
-      static_cast<RequestPriority>(priority_));
+      origin, domain_bound_cert_type_, domain_bound_private_key_,
+      domain_bound_cert_, static_cast<RequestPriority>(priority_));
   if (rv != ERR_IO_PENDING)
     return rv;
   return OK;
 }
 
-int SpdyStream::DoSendOriginBoundCertComplete(int result) {
+int SpdyStream::DoSendDomainBoundCertComplete(int result) {
   if (result < 0)
     return result;
 
   io_state_ = STATE_SEND_HEADERS;
   return OK;
 }
 
 int SpdyStream::DoSendHeaders() {
   CHECK(!cancelled_);
 
@@ skipping 81 matching lines @@
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
       recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
       recv_last_byte_time_ - send_time_);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 }  // namespace net