[Cronet] Continue UrlRequest with NULL certificate if Client cert is requested.

net/test/url_request/url_request_failed_job.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/test/url_request/url_request_failed_job.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
+#include "net/ssl/ssl_cert_request_info.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 
 namespace net {
 
 namespace {
 
 const char kMockHostname[] = "mock.failed.request";
 
 // String names of failure phases matching FailurePhase enum.
 const char* kFailurePhase[]{
     "start",      // START
     "readsync",   // READ_SYNC
     "readasync",  // READ_ASYNC
+    "certreq",    // CERT_REQUESTED
 };
 
 static_assert(arraysize(kFailurePhase) ==
                   URLRequestFailedJob::FailurePhase::MAX_FAILURE_PHASE,
               "kFailurePhase must match FailurePhase enum");
 
 class MockJobInterceptor : public URLRequestInterceptor {
  public:
   MockJobInterceptor() {}
   ~MockJobInterceptor() override {}
@@ skipping 20 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockJobInterceptor);
 };
 
 GURL GetMockUrl(const std::string& scheme,
                 const std::string& hostname,
                 URLRequestFailedJob::FailurePhase phase,
                 int net_error) {
   CHECK_GE(phase, URLRequestFailedJob::FailurePhase::START);
-  CHECK_LE(phase, URLRequestFailedJob::FailurePhase::READ_ASYNC);
+  CHECK_LT(phase, URLRequestFailedJob::FailurePhase::MAX_FAILURE_PHASE);
   CHECK_LT(net_error, OK);
   return GURL(scheme + "://" + hostname + "/error?" + kFailurePhase[phase] +
               "=" + base::IntToString(net_error));
 }
 
 }  // namespace
 
 URLRequestFailedJob::URLRequestFailedJob(URLRequest* request,
                                          NetworkDelegate* network_delegate,
                                          FailurePhase phase,
                                          int net_error)
     : URLRequestJob(request, network_delegate),
       phase_(phase),
       net_error_(net_error),
       weak_factory_(this) {
   CHECK_GE(phase, URLRequestFailedJob::FailurePhase::START);
-  CHECK_LE(phase, URLRequestFailedJob::FailurePhase::READ_ASYNC);
+  CHECK_LT(phase, URLRequestFailedJob::FailurePhase::MAX_FAILURE_PHASE);
   CHECK_LT(net_error, OK);
 }
 
 URLRequestFailedJob::URLRequestFailedJob(URLRequest* request,
                                          NetworkDelegate* network_delegate,
                                          int net_error)
     : URLRequestFailedJob(request, network_delegate, START, net_error) {
 }
 
 void URLRequestFailedJob::Start() {
@@ skipping 13 matching lines @@
   return ERR_IO_PENDING;
 }
 
 int URLRequestFailedJob::GetResponseCode() const {
   // If we have headers, get the response code from them.
   if (response_info_.headers)
     return response_info_.headers->response_code();
   return URLRequestJob::GetResponseCode();
 }
 
+void URLRequestFailedJob::ContinueWithCertificate(
+    X509Certificate* client_cert,
+    SSLPrivateKey* client_private_key) {
+  NotifyStartError(URLRequestStatus::FromError(net_error_));
+}
+
 void URLRequestFailedJob::GetResponseInfo(HttpResponseInfo* info) {
   *info = response_info_;
 }
 
 // static
 void URLRequestFailedJob::AddUrlHandler() {
   return AddUrlHandlerForHostname(kMockHostname);
 }
 
 // static
@@ skipping 44 matching lines @@
 
 void URLRequestFailedJob::StartAsync() {
   if (phase_ == START) {
     if (net_error_ != ERR_IO_PENDING) {
       NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, net_error_));
       return;
     }
     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
     return;
   }
+  if (phase_ == CERT_REQUESTED) {
+    scoped_refptr<SSLCertRequestInfo> request_all(new SSLCertRequestInfo());
+    NotifyCertificateRequested(request_all.get());
+    return;
+  }
   response_info_.headers = new net::HttpResponseHeaders("HTTP/1.1 200 OK");
   NotifyHeadersComplete();
 }
 
 }  // namespace net