Disable Name Mismatch redirection for non-overridable SSL errors

chrome/browser/ssl/ssl_error_handler_unittest.cc

 // Copyright 2014 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 "chrome/browser/ssl/ssl_error_handler.h"
 
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
@@ skipping 24 matching lines @@
                         GURL(),
                         0,
                         nullptr,
                         base::Callback<void(bool)>()),
         profile_(profile),
         captive_portal_checked_(false),
         suggested_url_exists_(false),
         suggested_url_checked_(false),
         ssl_interstitial_shown_(false),
         captive_portal_interstitial_shown_(false),
-        common_name_mismatch_redirect_(false) {}
+        common_name_mismatch_redirect_(false),
+        is_overridable_error_(true) {}
 
   ~TestSSLErrorHandler() override {
   }
 
   using SSLErrorHandler::StartHandlingError;
 
   void SendCaptivePortalNotification(
       captive_portal::CaptivePortalResult result) {
     CaptivePortalService::Results results;
     results.previous_result = captive_portal::RESULT_INTERNET_CONNECTED;
@@ skipping 37 matching lines @@
     *suggested_url = GURL("www.example.com");
     return true;
   }
 
   bool suggested_url_checked() const { return suggested_url_checked_; }
 
   bool common_name_mismatch_redirect() const {
     return common_name_mismatch_redirect_;
   }
 
+  void set_non_overridable_error() { is_overridable_error_ = false; }
+
   void Reset() {
     captive_portal_checked_ = false;
     suggested_url_exists_ = false;
     suggested_url_checked_ = false;
     ssl_interstitial_shown_ = false;
     captive_portal_interstitial_shown_ = false;
     common_name_mismatch_redirect_ = false;
   }
 
  private:
   void CheckForCaptivePortal() override {
     captive_portal_checked_ = true;
   }
 
   void ShowSSLInterstitial() override { ssl_interstitial_shown_ = true; }
 
   void ShowCaptivePortalInterstitial(const GURL& landing_url) override {
     captive_portal_interstitial_shown_ = true;
   }
 
   void CheckSuggestedUrl(const GURL& suggested_url) override {
     suggested_url_checked_ = true;
   }
 
   void NavigateToSuggestedURL(const GURL& suggested_url) override {
     common_name_mismatch_redirect_ = true;
   }
 
+  bool IsErrorOverridable() const override { return is_overridable_error_; }
+
   Profile* profile_;
   bool captive_portal_checked_;
   bool suggested_url_exists_;
   bool suggested_url_checked_;
   bool ssl_interstitial_shown_;
   bool captive_portal_interstitial_shown_;
   bool common_name_mismatch_redirect_;
+  bool is_overridable_error_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSSLErrorHandler);
 };
 
 class SSLErrorHandlerTest : public ChromeRenderViewHostTestHarness {
  public:
   SSLErrorHandlerTest()
       : field_trial_list_(NULL) {
   }
 
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     SSLErrorHandler::SetInterstitialDelayTypeForTest(SSLErrorHandler::NONE);
     ssl_info_.cert =
         net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
     ssl_info_.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
     error_handler_.reset(new TestSSLErrorHandler(profile(),
                                                  web_contents(),
                                                  ssl_info_));
     // Enable finch experiment for captive portal interstitials.
     ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
                     "CaptivePortalInterstitial", "Enabled"));
     // Enable finch experiment for SSL common name mismatch handling.
     ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-                    "SSLCommonNameMismatchHandling", "Enabled"));
+        "SSLCommonNameMismatchHandling", "Enabled"));
   }
 
   void TearDown() override {
     EXPECT_FALSE(error_handler()->IsTimerRunning());
     error_handler_.reset(NULL);
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
   TestSSLErrorHandler* error_handler() { return error_handler_.get(); }
 
@@ skipping 88 matching lines @@
 
   EXPECT_TRUE(error_handler()->IsTimerRunning());
   EXPECT_TRUE(error_handler()->suggested_url_checked());
   EXPECT_FALSE(error_handler()->captive_portal_checked());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(error_handler()->IsTimerRunning());
   EXPECT_TRUE(error_handler()->ssl_interstitial_shown());
 }
 
+TEST_F(SSLErrorHandlerTest, ShouldNotHandleNameMismatchOnNonOverridableError) {
+  error_handler()->SetSuggestedUrlExists(true);
+  error_handler()->set_non_overridable_error();

[meacer, 2015/08/21 01:00:10]

nit: Move this to the first line, so that it's a bit clearer what the test is
doing.

[Bhanu Dev, 2015/08/21 01:11:26]

Done.

+  error_handler()->StartHandlingError();
+
+  EXPECT_FALSE(error_handler()->suggested_url_checked());
+  EXPECT_TRUE(error_handler()->captive_portal_checked());
+  EXPECT_TRUE(error_handler()->IsTimerRunning());
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_FALSE(error_handler()->IsTimerRunning());
+  EXPECT_TRUE(error_handler()->ssl_interstitial_shown());
+}
+
 #else  // #if !defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
 
 TEST_F(SSLErrorHandlerTest,
        ShouldShowSSLInterstitialOnCaptivePortalDetectionDisabled) {
   EXPECT_FALSE(error_handler()->IsTimerRunning());
   error_handler()->SetSuggestedUrlExists(false);
   error_handler()->StartHandlingError();
   EXPECT_FALSE(error_handler()->IsTimerRunning());
   EXPECT_FALSE(error_handler()->captive_portal_checked());
   EXPECT_TRUE(error_handler()->ssl_interstitial_shown());
@@ skipping 51 matching lines @@
   // Fake an Invalid Suggested URL Check result.
   error_handler()->SendSuggestedUrlCheckResult(
       CommonNameMismatchHandler::SuggestedUrlCheckResult::
           SUGGESTED_URL_NOT_AVAILABLE,
       GURL());
 
   EXPECT_FALSE(error_handler()->IsTimerRunning());
   EXPECT_TRUE(error_handler()->ssl_interstitial_shown());
   EXPECT_FALSE(error_handler()->common_name_mismatch_redirect());
 }