Plumbing SSLPrivateKey (//net)

net/http/http_cache_transaction.h

 // 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.
 
 // This file declares HttpCache::Transaction, a private class of HttpCache so
 // it should only be included by http_cache.cc
 
 #ifndef NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 #define NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 
@@ skipping 21 matching lines @@
 #include "net/http/partial_data.h"
 #include "net/log/net_log.h"
 #include "net/socket/connection_attempts.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 
 namespace net {
 
 class PartialData;
 struct HttpRequestInfo;
 struct LoadTimingInfo;
+class SSLPrivateKey;
 
 // This is the transaction that is returned by the HttpCache transaction
 // factory.
 class HttpCache::Transaction : public HttpTransaction {
  public:
   // The transaction has the following modes, which apply to how it may access
   // its cache entry.
   //
   //  o If the mode of the transaction is NONE, then it is in "pass through"
   //    mode and all methods just forward to the inner network transaction.
@@ skipping 75 matching lines @@
   void FailConditionalizationForTest() {
     fail_conditionalization_for_test_ = true;
   }
 
   // HttpTransaction methods:
   int Start(const HttpRequestInfo* request_info,
             const CompletionCallback& callback,
             const BoundNetLog& net_log) override;
   int RestartIgnoringLastError(const CompletionCallback& callback) override;
   int RestartWithCertificate(X509Certificate* client_cert,
+                             SSLPrivateKey* client_private_key,
                              const CompletionCallback& callback) override;
   int RestartWithAuth(const AuthCredentials& credentials,
                       const CompletionCallback& callback) override;
   bool IsReadyToRestartForAuth() override;
   int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override;
   void StopCaching() override;
   bool GetFullRequestHeaders(HttpRequestHeaders* headers) const override;
   int64_t GetTotalReceivedBytes() const override;
@@ skipping 179 matching lines @@
   // conditionalized internally in response to LOAD_VALIDATE_CACHE).
   // Returns a network error code.
   int BeginExternallyConditionalizedRequest();
 
   // Called to restart a network transaction after an error.  Returns network
   // error code.
   int RestartNetworkRequest();
 
   // Called to restart a network transaction with a client certificate.
   // Returns network error code.
-  int RestartNetworkRequestWithCertificate(X509Certificate* client_cert);
+  int RestartNetworkRequestWithCertificate(X509Certificate* client_cert,
+                                           SSLPrivateKey* client_private_key);
 
   // Called to restart a network transaction with authentication credentials.
   // Returns network error code.
   int RestartNetworkRequestWithAuth(const AuthCredentials& credentials);
 
   // Called to determine if we need to validate the cache entry before using it,
   // and whether the validation should be synchronous or asynchronous.
   ValidationType RequiresValidation();
 
   // Called to make the request conditional (to ask the server if the cached
@@ skipping 147 matching lines @@
   BeforeProxyHeadersSentCallback before_proxy_headers_sent_callback_;
 
   base::WeakPtrFactory<Transaction> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Transaction);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_TRANSACTION_H_