Support host-based deletion for SSLHostStateDelegate

chrome/browser/ssl/chrome_ssl_host_state_delegate_test.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/chrome_ssl_host_state_delegate.h"
 
 #include <stdint.h>
 #include <utility>
 
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_clock.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ssl/chrome_ssl_host_state_delegate_factory.h"
@@ skipping 25 matching lines @@
 scoped_refptr<net::X509Certificate> GetOkCert() {
   return net::ImportCertFromFile(net::GetTestCertsDirectory(), kOkCertFile);
 }
 
 // Helper function for setting Finch options
 void SetFinchConfig(base::CommandLine* command_line, const std::string& group) {
   command_line->AppendSwitchASCII("--force-fieldtrials",
                                   "RevertCertificateErrorDecisions/" + group);
 }
 
+bool CStrStringMatcher(const char* a, const std::string& b) {
+  return a == b;
+}
+
 }  // namespace
 
 class ChromeSSLHostStateDelegateTest : public InProcessBrowserTest {};
 
 // ChromeSSLHostStateDelegateTest tests basic unit test functionality of the
 // SSLHostStateDelegate class.  For example, tests that if a certificate is
 // accepted, then it is added to queryable, and if it is revoked, it is not
 // queryable. Even though it is effectively a unit test, in needs to be an
 // InProcessBrowserTest because the actual functionality is provided by
 // ChromeSSLHostStateDelegate which is provided per-profile.
@@ skipping 99 matching lines @@
   content::WebContents* tab =
       browser()->tab_strip_model()->GetActiveWebContents();
   Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
   ChromeSSLHostStateDelegate* state =
       ChromeSSLHostStateDelegateFactory::GetForProfile(profile);
   bool unused_value;
 
   // Simulate a user decision to allow an invalid certificate exception for
   // kWWWGoogleHost and for kExampleHost.
   state->AllowCert(kWWWGoogleHost, *cert, net::CERT_STATUS_DATE_INVALID);
+  state->AllowCert(kExampleHost, *cert, net::CERT_STATUS_DATE_INVALID);
 
-  // Do a full clear, then make sure that both kWWWGoogleHost, which had a
-  // decision made, and kExampleHost, which was untouched, are now in a denied
-  // state.
-  state->Clear();
+  EXPECT_TRUE(state->HasAllowException(kWWWGoogleHost));
+  EXPECT_TRUE(state->HasAllowException(kExampleHost));
+
+  // Clear data for kWWWGoogleHost. kExampleHost will not be modified.
+  state->Clear(
+      base::Bind(&CStrStringMatcher, base::Unretained(kWWWGoogleHost)));
+
+  EXPECT_FALSE(state->HasAllowException(kWWWGoogleHost));
+  EXPECT_TRUE(state->HasAllowException(kExampleHost));
+
+  // Do a full clear, then make sure that both kWWWGoogleHost and kExampleHost,
+  // which had a decision made, and kGoogleHost, which was untouched, are now
+  // in a denied state.
+  state->Clear(base::Callback<bool(const std::string&)>());
   EXPECT_FALSE(state->HasAllowException(kWWWGoogleHost));
   EXPECT_EQ(content::SSLHostStateDelegate::DENIED,
             state->QueryPolicy(kWWWGoogleHost, *cert,
                                net::CERT_STATUS_DATE_INVALID, &unused_value));
   EXPECT_FALSE(state->HasAllowException(kExampleHost));
   EXPECT_EQ(content::SSLHostStateDelegate::DENIED,
             state->QueryPolicy(kExampleHost, *cert,
                                net::CERT_STATUS_DATE_INVALID, &unused_value));
+  EXPECT_FALSE(state->HasAllowException(kGoogleHost));
+  EXPECT_EQ(content::SSLHostStateDelegate::DENIED,
+            state->QueryPolicy(kGoogleHost, *cert,
+                               net::CERT_STATUS_DATE_INVALID, &unused_value));
 }
 
 // DidHostRunInsecureContent unit tests the expected behavior of calling
 // DidHostRunInsecureContent as well as HostRanInsecureContent to check if
 // insecure content has been run and to mark it as such.
 IN_PROC_BROWSER_TEST_F(ChromeSSLHostStateDelegateTest,
                        DidHostRunInsecureContent) {
   content::WebContents* tab =
       browser()->tab_strip_model()->GetActiveWebContents();
   Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
@@ skipping 479 matching lines @@
   EXPECT_EQ(
       content::SSLHostStateDelegate::ALLOWED,
       state->QueryPolicy("localhost", *cert,
                          net::CERT_STATUS_COMMON_NAME_INVALID, &unused_value));
 
   EXPECT_EQ(
       content::SSLHostStateDelegate::ALLOWED,
       state->QueryPolicy("127.0.0.1", *cert,
                          net::CERT_STATUS_COMMON_NAME_INVALID, &unused_value));
 }