Plumbing SSLPrivateKey

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 13 matching lines @@
 #include "net/base/request_priority.h"
 #include "net/base/upload_progress.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/partial_data.h"
 #include "net/log/net_log.h"
 #include "net/socket/connection_attempts.h"
+#include "net/ssl/ssl_private_key.h"

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

Forward decl

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

Done.

 #include "net/websockets/websocket_handshake_stream_base.h"
 
 namespace net {
 
 class PartialData;
 struct HttpRequestInfo;
 struct LoadTimingInfo;
 
 // This is the transaction that is returned by the HttpCache transaction
 // factory.
@@ skipping 82 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_pkey,
                              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 178 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_pkey);
 
   // 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 146 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_