[subresource_filter] Make website setting existence imply site activation

chrome/browser/subresource_filter/subresource_filter_content_settings_manager.cc

 // Copyright 2017 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/subresource_filter/subresource_filter_content_settings_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
 SubresourceFilterContentSettingsManager::
     SubresourceFilterContentSettingsManager(Profile* profile)
     : history_observer_(this),
       settings_map_(HostContentSettingsMapFactory::GetForProfile(profile)),
       clock_(base::MakeUnique<base::DefaultClock>(base::DefaultClock())),
       should_use_smart_ui_(ShouldUseSmartUI()) {
   DCHECK(profile);
   DCHECK(settings_map_);
   settings_map_->AddObserver(this);
 
-  if (should_use_smart_ui()) {
-    if (auto* history_service = HistoryServiceFactory::GetForProfile(
-            profile, ServiceAccessType::EXPLICIT_ACCESS)) {
-      history_observer_.Add(history_service);
-    }
+  if (auto* history_service = HistoryServiceFactory::GetForProfile(
+          profile, ServiceAccessType::EXPLICIT_ACCESS)) {
+    history_observer_.Add(history_service);
   }
 }
 
 SubresourceFilterContentSettingsManager::
     ~SubresourceFilterContentSettingsManager() {
   settings_map_->RemoveObserver(this);
   settings_map_ = nullptr;
   history_observer_.RemoveAll();
 }
 
 ContentSetting SubresourceFilterContentSettingsManager::GetSitePermission(
     const GURL& url) const {
   return settings_map_->GetContentSetting(
       url, GURL(),
       ContentSettingsType::CONTENT_SETTINGS_TYPE_SUBRESOURCE_FILTER,
       std::string());
 }
 
 void SubresourceFilterContentSettingsManager::WhitelistSite(const GURL& url) {
   base::AutoReset<bool> resetter(&ignore_settings_changes_, true);
   settings_map_->SetContentSettingDefaultScope(
       url, GURL(),
       ContentSettingsType::CONTENT_SETTINGS_TYPE_SUBRESOURCE_FILTER,
       std::string(), CONTENT_SETTING_BLOCK);
   ChromeSubresourceFilterClient::LogAction(kActionContentSettingsBlockedFromUI);
 }
 
 void SubresourceFilterContentSettingsManager::OnDidShowUI(const GURL& url) {
-  if (!should_use_smart_ui())
-    return;
   auto dict = base::MakeUnique<base::DictionaryValue>();
   double now = clock_->Now().ToDoubleT();
   dict->SetDouble(kInfobarLastShownTimeKey, now);
   SetSiteMetadata(url, std::move(dict));
 }
 
 bool SubresourceFilterContentSettingsManager::ShouldShowUIForSite(
     const GURL& url) const {
   if (!should_use_smart_ui())
     return true;
 
   std::unique_ptr<base::DictionaryValue> dict = GetSiteMetadata(url);
   if (!dict)
     return true;
 
   double last_shown_time_double = 0;
   if (dict->GetDouble(kInfobarLastShownTimeKey, &last_shown_time_double)) {
     base::Time last_shown = base::Time::FromDoubleT(last_shown_time_double);
     if (clock_->Now() - last_shown < kDelayBeforeShowingInfobarAgain)
       return false;
   }
   return true;
 }
 
+void SubresourceFilterContentSettingsManager::ClearSiteMetadata(
+    const GURL& url) {
+  SetSiteMetadata(url, nullptr);
+}
+
 std::unique_ptr<base::DictionaryValue>
 SubresourceFilterContentSettingsManager::GetSiteMetadata(
     const GURL& url) const {
   return base::DictionaryValue::From(settings_map_->GetWebsiteSetting(
       url, GURL(), CONTENT_SETTINGS_TYPE_SUBRESOURCE_FILTER_DATA, std::string(),
       nullptr));
 }
 
 void SubresourceFilterContentSettingsManager::SetSiteMetadata(
     const GURL& url,
@@ skipping 48 matching lines @@
       url, url, ContentSettingsType::CONTENT_SETTINGS_TYPE_SUBRESOURCE_FILTER,
       std::string());
   if (setting == CONTENT_SETTING_BLOCK) {
     ChromeSubresourceFilterClient::LogAction(kActionContentSettingsBlocked);
   } else if (setting == CONTENT_SETTING_ALLOW) {
     ChromeSubresourceFilterClient::LogAction(kActionContentSettingsAllowed);
   } else {
     NOTREACHED();
   }
 
-  if (!should_use_smart_ui())
-    return;
-
   if (!ShouldShowUIForSite(url)) {
     ChromeSubresourceFilterClient::LogAction(
         kActionContentSettingsBlockedWhileUISuppressed);
   }
-
-  // Reset the smart UI to ensure the user can easily change their decision.
-  SetSiteMetadata(url, nullptr);
+  // Note: could potentially reset the smart UI here to enable the user to
+  // easily change their decision. If that code is added we should make sure not
+  // to delete the metadata, but merely remove / reset the timestamp.
 }
 
 // When history URLs are deleted, clear the metadata for the smart UI.
 void SubresourceFilterContentSettingsManager::OnURLsDeleted(
     history::HistoryService* history_service,
     bool all_history,
     bool expired,
     const history::URLRows& deleted_rows,
     const std::set<GURL>& favicon_urls) {
-  DCHECK(should_use_smart_ui());
   if (all_history) {
     settings_map_->ClearSettingsForOneType(
         CONTENT_SETTINGS_TYPE_SUBRESOURCE_FILTER_DATA);
     return;
   }
 
   // Careful note: This clears the setting even if there are other URLs with the
   // same origin in the history. i.e. this is an aggressive policy.
   for (const auto& deleted_row : deleted_rows) {
     SetSiteMetadata(deleted_row.url(), nullptr);
   }
 }