Plumbing SSLPrivateKey

net/http/http_cache_transaction.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/http/http_cache_transaction.h"
 
 #include "build/build_config.h"  // For OS_POSIX
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 25 matching lines @@
 #include "net/base/upload_data_stream.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/x509_certificate.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/disk_based_cert_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_util.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_config_service.h"
+#include "net/ssl/ssl_private_key.h"

[davidben, 2015/09/25 20:10:11]

Not necessary

[svaldez, 2015/09/28 16:54:52]

Done.

 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 
 namespace {
 
 // TODO(ricea): Move this to HttpResponseHeaders once it is standardised.
@@ skipping 343 matching lines @@
   int rv = RestartNetworkRequest();
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartWithCertificate(
     X509Certificate* client_cert,
+    SSLPrivateKey* client_pkey,
     const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(callback_.is_null());
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
-  int rv = RestartNetworkRequestWithCertificate(client_cert);
+  int rv = RestartNetworkRequestWithCertificate(client_cert, client_pkey);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartWithAuth(
     const AuthCredentials& credentials,
     const CompletionCallback& callback) {
@@ skipping 1847 matching lines @@
   DCHECK_EQ(STATE_NONE, next_state_);
 
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
   int rv = network_trans_->RestartIgnoringLastError(io_callback_);
   if (rv != ERR_IO_PENDING)
     return DoLoop(rv);
   return rv;
 }
 
 int HttpCache::Transaction::RestartNetworkRequestWithCertificate(
-    X509Certificate* client_cert) {
+    X509Certificate* client_cert,
+    SSLPrivateKey* client_pkey) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
   DCHECK_EQ(STATE_NONE, next_state_);
 
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
-  int rv = network_trans_->RestartWithCertificate(client_cert, io_callback_);
+  int rv = network_trans_->RestartWithCertificate(client_cert, client_pkey,
+                                                  io_callback_);
   if (rv != ERR_IO_PENDING)
     return DoLoop(rv);
   return rv;
 }
 
 int HttpCache::Transaction::RestartNetworkRequestWithAuth(
     const AuthCredentials& credentials) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
   DCHECK_EQ(STATE_NONE, next_state_);
@@ skipping 631 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net