Log server advertised protos and the selected

net/socket/ssl_client_socket_nss.cc

 // Copyright (c) 2011 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.
 
 // This file includes code SSLClientSocketNSS::DoVerifyCertComplete() derived
 // from AuthCertificateCallback() in
 // mozilla/security/manager/ssl/src/nsNSSCallbacks.cpp.
 
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
@@ skipping 538 matching lines @@
       reinterpret_cast<const unsigned char*>(context.data()),
       context.length(), out, outlen);
   if (result != SECSuccess) {
     LogFailedNSSFunction(net_log_, "SSL_ExportKeyingMaterial", "");
     return MapNSSError(PORT_GetError());
   }
   return OK;
 }
 
 SSLClientSocket::NextProtoStatus
-SSLClientSocketNSS::GetNextProto(std::string* proto) {
+SSLClientSocketNSS::GetNextProto(std::string* proto,
+                                 std::string* server_proto) {

[agl, 2011/12/05 16:38:10]

s

[ramant (doing other things), 2011/12/05 19:03:28]

Done.

   *proto = next_proto_;
+  *server_proto = protos_;
   return next_proto_status_;
 }
 
 int SSLClientSocketNSS::Connect(OldCompletionCallback* callback) {
   EnterFunction("");
   DCHECK(transport_.get());
   DCHECK(next_handshake_state_ == STATE_NONE);
   DCHECK(!user_read_callback_);
   DCHECK(!user_write_callback_);
   DCHECK(!user_connect_callback_);
@@ skipping 2020 matching lines @@
     }
 
     if (that->next_proto_status_ == kNextProtoNegotiated)
       break;
 
     // NSS checks that the data in |protos| is well formed, so we know that
     // this doesn't cause us to jump off the end of the buffer.
     i += len + 1;
   }
 
+  that->protos_.assign(reinterpret_cast<const char*>(protos), protos_len);
+
   // If we didn't find a protocol, we select the first one from our list.
   if (that->next_proto_status_ != kNextProtoNegotiated) {
     that->next_proto_status_ = kNextProtoNoOverlap;
     that->next_proto_ = that->ssl_config_.next_protos[0];
   }
 
   memcpy(proto_out, that->next_proto_.data(), that->next_proto_.size());
   *proto_out_len = that->next_proto_.size();
   return SECSuccess;
 }
 
 void SSLClientSocketNSS::EnsureThreadIdAssigned() const {
   base::AutoLock auto_lock(lock_);
   if (valid_thread_id_ != base::kInvalidThreadId)
     return;
   valid_thread_id_ = base::PlatformThread::CurrentId();
 }
 
 bool SSLClientSocketNSS::CalledOnValidThread() const {
   EnsureThreadIdAssigned();
   base::AutoLock auto_lock(lock_);
   return valid_thread_id_ == base::PlatformThread::CurrentId();
 }
 
 }  // namespace net