Common Name Mismatch Handler For WWW Subdomain Mismatch case

chrome/browser/captive_portal/captive_portal_browsertest.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 <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 36 matching lines @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/base/net_errors.h"
+#include "net/base/test_data_directory.h"
+#include "net/cert/x509_certificate.h"
 #include "net/http/transport_security_state.h"
+#include "net/test/cert_test_util.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 69 matching lines @@
   static void WaitForJobs(int num_jobs);
 
   // Fails all active URLRequestTimeoutOnDemandJobs with connection timeouts.
   // There are expected to be exactly |expected_num_jobs| waiting for
   // failure.  The only way to guarantee this is with an earlier call to
   // WaitForJobs, so makes sure there has been a matching WaitForJobs call.
   static void FailJobs(int expected_num_jobs);
 
   // Fails all active URLRequestTimeoutOnDemandJobs with SSL cert errors.
   // |expected_num_jobs| behaves just as in FailJobs.
-  static void FailJobsWithCertError(int expected_num_jobs);
+  static void FailJobsWithCertError(int expected_num_jobs,
+                                    const net::SSLInfo& ssl_info);
 
   // Abandon all active URLRequestTimeoutOnDemandJobs.  |expected_num_jobs|
   // behaves just as in FailJobs.
   static void AbandonJobs(int expected_num_jobs);
 
  private:
   friend class URLRequestMockCaptivePortalJobFactory;
 
   // Operation to perform on jobs when removing them from |job_list_|.
   enum EndJobOperation {
     FAIL_JOBS,
     ABANDON_JOBS,
     FAIL_JOBS_WITH_CERT_ERROR
   };
 
   URLRequestTimeoutOnDemandJob(net::URLRequest* request,
                                net::NetworkDelegate* network_delegate);
   ~URLRequestTimeoutOnDemandJob() override;
 
   // Attempts to removes |this| from |jobs_|.  Returns true if it was removed
   // from the list.
   bool RemoveFromList();
 
   static void WaitForJobsOnIOThread(int num_jobs);
-  static void FailOrAbandonJobsOnIOThread(
-      int expected_num_jobs,
-      EndJobOperation end_job_operation);
+  static void FailOrAbandonJobsOnIOThread(int expected_num_jobs,
+                                          EndJobOperation end_job_operation,
+                                          const net::SSLInfo& ssl_info);
 
   // Checks if there are at least |num_jobs_to_wait_for_| jobs in
   // |job_list_|.  If so, exits the message loop on the UI thread, which
   // should be spinning in a call to WaitForJobs.  Does nothing when
   // |num_jobs_to_wait_for_| is 0.
   static void MaybeStopWaitingForJobsOnIOThread();
 
   // All class variables are only accessed on the IO thread.
 
   // Number of jobs currently being waited for, or 0 if not currently
@@ skipping 47 matching lines @@
       base::Bind(&URLRequestTimeoutOnDemandJob::WaitForJobsOnIOThread,
                  num_jobs));
   content::RunMessageLoop();
 }
 
 // static
 void URLRequestTimeoutOnDemandJob::FailJobs(int expected_num_jobs) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&URLRequestTimeoutOnDemandJob::FailOrAbandonJobsOnIOThread,
-                 expected_num_jobs,
-                 FAIL_JOBS));
+                 expected_num_jobs, FAIL_JOBS, net::SSLInfo()));
 }
 
 // static
 void URLRequestTimeoutOnDemandJob::FailJobsWithCertError(
-    int expected_num_jobs) {
+    int expected_num_jobs,
+    const net::SSLInfo& ssl_info) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&URLRequestTimeoutOnDemandJob::FailOrAbandonJobsOnIOThread,
-                 expected_num_jobs,
-                 FAIL_JOBS_WITH_CERT_ERROR));
+                 expected_num_jobs, FAIL_JOBS_WITH_CERT_ERROR, ssl_info));
 }
 
 // static
 void URLRequestTimeoutOnDemandJob::AbandonJobs(int expected_num_jobs) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&URLRequestTimeoutOnDemandJob::FailOrAbandonJobsOnIOThread,
-                 expected_num_jobs,
-                 ABANDON_JOBS));
+                 expected_num_jobs, ABANDON_JOBS, net::SSLInfo()));
 }
 
 URLRequestTimeoutOnDemandJob::URLRequestTimeoutOnDemandJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate)
     : net::URLRequestJob(request, network_delegate),
       next_job_(NULL) {
 }
 
 URLRequestTimeoutOnDemandJob::~URLRequestTimeoutOnDemandJob() {
   // All hanging jobs should have failed or been abandoned before being
@@ skipping 44 matching lines @@
     last_num_jobs_to_wait_for_ = num_jobs_to_wait_for_;
     num_jobs_to_wait_for_ = 0;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::MessageLoop::QuitClosure());
   }
 }
 
 // static
 void URLRequestTimeoutOnDemandJob::FailOrAbandonJobsOnIOThread(
     int expected_num_jobs,
-    EndJobOperation end_job_operation) {
+    EndJobOperation end_job_operation,
+    const net::SSLInfo& ssl_info) {
   ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ASSERT_LT(0, expected_num_jobs);
   EXPECT_EQ(last_num_jobs_to_wait_for_, expected_num_jobs);
   last_num_jobs_to_wait_for_ = 0;
 
   int num_jobs = 0;
   while (job_list_) {
     ++num_jobs;
     URLRequestTimeoutOnDemandJob* job = job_list_;
     // Since the error notification may result in the job's destruction, remove
     // it from the job list before the error.
     EXPECT_TRUE(job->RemoveFromList());
     if (end_job_operation == FAIL_JOBS) {
       job->NotifyStartError(net::URLRequestStatus(
                                 net::URLRequestStatus::FAILED,
                                 net::ERR_CONNECTION_TIMED_OUT));
     } else if (end_job_operation == FAIL_JOBS_WITH_CERT_ERROR) {
       DCHECK(job->request()->url().SchemeIsCryptographic());
-      net::SSLInfo info;
-      info.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
-      info.cert = new net::X509Certificate(
-          "bad.host", "CA", base::Time::Max(), base::Time::Max());
-      job->NotifySSLCertificateError(info, true);
+      job->NotifySSLCertificateError(ssl_info, true);
     }
   }
 
   EXPECT_EQ(expected_num_jobs, num_jobs_started_);
   EXPECT_EQ(expected_num_jobs, num_jobs);
 
   num_jobs_started_ -= expected_num_jobs;
 }
 
 // URLRequestCaptivePortalJobFactory emulates captive portal behavior.
@@ skipping 2495 matching lines @@
   WebContents* broken_tab_contents = tab_strip_model->GetActiveWebContents();
   SlowLoadBehindCaptivePortal(browser(), true, cert_error_url, 1, 1);
 
   // No longer behind a captive portal. Committing the SSL page should trigger
   // an SSL interstitial which triggers a new captive portal check. Since there
   // is no captive portal anymore, should end up with an SSL interstitial.
   factory_.SetBehindCaptivePortal(false);
 
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver navigation_observer;
-  URLRequestTimeoutOnDemandJob::FailJobsWithCertError(1);
+  net::SSLInfo info;
+  info.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
+  info.cert =
+      net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
+  URLRequestTimeoutOnDemandJob::FailJobsWithCertError(1, info);
   navigation_observer.WaitForNavigations(1);
 
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
             GetStateOfTabReloaderAt(browser(), broken_tab_index));
 
   WaitForInterstitialAttach(broken_tab_contents);
   portal_observer.WaitForResults(1);
 
   EXPECT_EQ(SSLBlockingPage::kTypeForTesting,
             GetInterstitialType(broken_tab_contents));
 }