Support host-based deletion for SSLHostStateDelegate

chrome/browser/browsing_data/browsing_data_remover.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 "chrome/browser/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 649 matching lines @@
         base::Bind(
             &WebRtcLogUtil::DeleteOldAndRecentWebRtcLogFiles,
             WebRtcLogList::GetWebRtcLogDirectoryForProfile(profile_->GetPath()),
             delete_begin_),
         base::Bind(&BrowsingDataRemover::OnClearedWebRtcLogs,
                    weak_ptr_factory_.GetWeakPtr()));
 #endif
 
     // The SSL Host State that tracks SSL interstitial "proceed" decisions may
     // include origins that the user has visited, so it must be cleared.
-    if (profile_->GetSSLHostStateDelegate())
-      profile_->GetSSLHostStateDelegate()->Clear();
+    // TODO(msramek): We can reuse the plugin filter here, since both plugins
+    // and SSL host state are scoped to hosts and represent them as std::string.
+    // Rename the method to indicate its more general usage.
+    if (profile_->GetSSLHostStateDelegate()) {
+      profile_->GetSSLHostStateDelegate()->Clear(
+          filter_builder.IsEmptyBlacklist()
+              ? base::Callback<bool(const std::string&)>()
+              : filter_builder.BuildPluginFilter());
+    }
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
     precache::PrecacheManager* precache_manager =
         precache::PrecacheManagerFactory::GetForBrowserContext(profile_);
     // |precache_manager| could be nullptr if the profile is off the record.
     if (!precache_manager) {
       waiting_for_clear_precache_history_ = true;
       precache_manager->ClearHistory();
       // The above calls are done on the UI thread but do their work on the DB
       // thread. So wait for it.
@@ skipping 161 matching lines @@
       // object to avoid having to copy them to callback methods.
       flash_lso_helper_->StartFetching(base::Bind(
           &BrowsingDataRemover::OnSitesWithFlashDataFetched,
           weak_ptr_factory_.GetWeakPtr(),
           filter_builder.BuildPluginFilter()));
     }
   }
 #endif
 
   if (remove_mask & REMOVE_SITE_USAGE_DATA) {
-    ClearSettingsForOneTypeWithPredicate(
-        HostContentSettingsMapFactory::GetForProfile(profile_),
-        CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
-        base::Bind(&ForwardPrimaryPatternCallback, same_pattern_filter));
+    HostContentSettingsMapFactory::GetForProfile(profile_)
+        ->ClearSettingsForOneTypeWithPredicate(
+            CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
+            base::Bind(&ForwardPrimaryPatternCallback, same_pattern_filter));
   }
 
   if (remove_mask & REMOVE_SITE_USAGE_DATA || remove_mask & REMOVE_HISTORY) {
-    ClearSettingsForOneTypeWithPredicate(
-        HostContentSettingsMapFactory::GetForProfile(profile_),
-        CONTENT_SETTINGS_TYPE_APP_BANNER,
-        base::Bind(&ForwardPrimaryPatternCallback, same_pattern_filter));
+    HostContentSettingsMapFactory::GetForProfile(profile_)
+        ->ClearSettingsForOneTypeWithPredicate(
+            CONTENT_SETTINGS_TYPE_APP_BANNER,
+            base::Bind(&ForwardPrimaryPatternCallback, same_pattern_filter));
 
     PermissionDecisionAutoBlocker::RemoveCountsByUrl(profile_, filter);
   }
 
   if (remove_mask & REMOVE_PASSWORDS) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Passwords"));
     password_manager::PasswordStore* password_store =
         PasswordStoreFactory::GetForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS).get();
 
@@ skipping 344 matching lines @@
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer)
     : time_range(time_range),
       remove_mask(remove_mask),
       origin_type_mask(origin_type_mask),
       filter_builder(std::move(filter_builder)),
       observer(observer) {}
 
 BrowsingDataRemover::RemovalTask::~RemovalTask() {}
 
-void BrowsingDataRemover::ClearSettingsForOneTypeWithPredicate(
-    HostContentSettingsMap* content_settings_map,
-    ContentSettingsType content_type,
-    const base::Callback<bool(const ContentSettingsPattern& primary_pattern,
-                              const ContentSettingsPattern& secondary_pattern)>&
-        predicate) {
-  ContentSettingsForOneType settings;
-  content_settings_map->GetSettingsForOneType(content_type, std::string(),
-                                              &settings);
-  for (const ContentSettingPatternSource& setting : settings) {
-    if (predicate.Run(setting.primary_pattern, setting.secondary_pattern)) {
-      content_settings_map->SetWebsiteSettingCustomScope(
-          setting.primary_pattern, setting.secondary_pattern, content_type,
-          std::string(), nullptr);
-    }
-  }
-}
-
 bool BrowsingDataRemover::AllDone() {
   return !waiting_for_synchronous_clear_operations_ &&
          !waiting_for_clear_autofill_origin_urls_ &&
          !waiting_for_clear_cache_ &&
          !waiting_for_clear_flash_content_licenses_ &&
          !waiting_for_clear_channel_ids_ && !waiting_for_clear_cookies_count_ &&
          !waiting_for_clear_domain_reliability_monitor_ &&
          !waiting_for_clear_form_ && !waiting_for_clear_history_ &&
          !waiting_for_clear_hostname_resolution_cache_ &&
          !waiting_for_clear_http_auth_cache_ &&
@@ skipping 284 matching lines @@
   waiting_for_clear_offline_page_data_ = false;
   NotifyIfDone();
 }
 #endif
 
 void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyIfDone();
 }