📰 Persist category dismissals

components/ntp_snippets/content_suggestions_service.cc

 // Copyright 2016 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 "components/ntp_snippets/content_suggestions_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/values.h"
+#include "components/ntp_snippets/pref_names.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/pref_service.h"
 #include "ui/gfx/image/image.h"
 
 namespace ntp_snippets {
 
 ContentSuggestionsService::ContentSuggestionsService(
     State state,
     history::HistoryService* history_service,
     PrefService* pref_service)
     : state_(state),
       history_service_observer_(this),
       ntp_snippets_service_(nullptr),
+      pref_service_(pref_service),
       user_classifier_(pref_service) {
   // Can be null in tests.
   if (history_service)
     history_service_observer_.Add(history_service);
+
+  RestoreDismissedCategoriesFromPrefs();
 }
 
 ContentSuggestionsService::~ContentSuggestionsService() = default;
 
 void ContentSuggestionsService::Shutdown() {
   ntp_snippets_service_ = nullptr;
   suggestions_by_category_.clear();
   providers_by_category_.clear();
   categories_.clear();
   providers_.clear();
   state_ = State::DISABLED;
   FOR_EACH_OBSERVER(Observer, observers_, ContentSuggestionsServiceShutdown());
 }
 
+// static
+void ContentSuggestionsService::RegisterProfilePrefs(
+    PrefRegistrySimple* registry) {
+  registry->RegisterListPref(prefs::kDismissedCategories);
+}
+
 CategoryStatus ContentSuggestionsService::GetCategoryStatus(
     Category category) const {
   if (state_ == State::DISABLED) {
     return CategoryStatus::ALL_SUGGESTIONS_EXPLICITLY_DISABLED;
   }
 
   auto iterator = providers_by_category_.find(category);
   if (iterator == providers_by_category_.end())
     return CategoryStatus::NOT_PROVIDED;
 
@@ skipping 88 matching lines @@
   DCHECK(removed) << "The dismissed suggestion " << suggestion_id
                   << " has already been removed. Providers must not call"
                   << " OnNewSuggestions in response to DismissSuggestion.";
 }
 
 void ContentSuggestionsService::DismissCategory(Category category) {
   auto providers_it = providers_by_category_.find(category);
   if (providers_it == providers_by_category_.end())
     return;
 
-  suggestions_by_category_[category].clear();
-  dismissed_providers_by_category_[providers_it->first] = providers_it->second;
-  providers_by_category_.erase(providers_it);
-  categories_.erase(
-      std::find(categories_.begin(), categories_.end(), category));
+  ContentSuggestionsProvider* provider = providers_it->second;
+  UnregisterCategory(category, provider);
+
+  dismissed_providers_by_category_[category] = provider;
+  StoreDismissedCategoriesToPrefs();
 }
 
 void ContentSuggestionsService::RestoreDismissedCategories() {
   // Make a copy as the original will be modified during iteration.
   auto dismissed_providers_by_category_copy = dismissed_providers_by_category_;
   for (const auto& category_provider_pair :
        dismissed_providers_by_category_copy) {
-    RegisterCategoryIfRequired(category_provider_pair.second,
-                               category_provider_pair.first);
+    RestoreDismissedCategory(category_provider_pair.first);
   }
+  StoreDismissedCategoriesToPrefs();
   DCHECK(dismissed_providers_by_category_.empty());
 }
 
 void ContentSuggestionsService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ContentSuggestionsService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ContentSuggestionsService::RegisterProvider(
     std::unique_ptr<ContentSuggestionsProvider> provider) {
   DCHECK(state_ == State::ENABLED);
   providers_.push_back(std::move(provider));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Private methods
 
 void ContentSuggestionsService::OnNewSuggestions(
     ContentSuggestionsProvider* provider,
     Category category,
     std::vector<ContentSuggestion> suggestions) {
-  if (RegisterCategoryIfRequired(provider, category))
+  if (TryRegisterProviderForCategory(provider, category)) {
     NotifyCategoryStatusChanged(category);
+  } else if (IsCategoryDismissed(category)) {
+    // The category has been registered as a dismissed one. We need to
+    // check if the dismissal can be cleared now that we received new data.
+    if (suggestions.empty())
+      return;
+
+    RestoreDismissedCategory(category);
+    StoreDismissedCategoriesToPrefs();
+
+    NotifyCategoryStatusChanged(category);
+  }
 
   if (!IsCategoryStatusAvailable(provider->GetCategoryStatus(category))) {
     // A provider shouldn't send us suggestions while it's not available.
     DCHECK(suggestions.empty());
     return;
   }
 
   suggestions_by_category_[category] = std::move(suggestions);
 
   // The positioning of the bookmarks category depends on whether it's empty.
   // TODO(treib): Remove this temporary hack, crbug.com/640568.
   if (category.IsKnownCategory(KnownCategories::BOOKMARKS))
     SortCategories();
 
   FOR_EACH_OBSERVER(Observer, observers_, OnNewSuggestions(category));
 }
 
 void ContentSuggestionsService::OnCategoryStatusChanged(
     ContentSuggestionsProvider* provider,
     Category category,
     CategoryStatus new_status) {
-  if (!IsCategoryStatusAvailable(new_status)) {
-    suggestions_by_category_.erase(category);
-  }
   if (new_status == CategoryStatus::NOT_PROVIDED) {
-    DCHECK(providers_by_category_.find(category) !=
-           providers_by_category_.end());
-    DCHECK_EQ(provider, providers_by_category_.find(category)->second);
-    DismissCategory(category);
+    UnregisterCategory(category, provider);
   } else {
-    RegisterCategoryIfRequired(provider, category);
+    if (!IsCategoryStatusAvailable(new_status))
+      suggestions_by_category_.erase(category);
+    TryRegisterProviderForCategory(provider, category);
     DCHECK_EQ(new_status, provider->GetCategoryStatus(category));
   }
-  NotifyCategoryStatusChanged(category);
+
+  if (!IsCategoryDismissed(category))
+    NotifyCategoryStatusChanged(category);
 }
 
 void ContentSuggestionsService::OnSuggestionInvalidated(
     ContentSuggestionsProvider* provider,
     const ContentSuggestion::ID& suggestion_id) {
   RemoveSuggestionByID(suggestion_id);
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnSuggestionInvalidated(suggestion_id));
 }
 
@@ skipping 36 matching lines @@
         deleted_urls);
     ClearHistory(begin, end, filter);
   }
 }
 
 void ContentSuggestionsService::HistoryServiceBeingDeleted(
     history::HistoryService* history_service) {
   history_service_observer_.RemoveAll();
 }
 
-bool ContentSuggestionsService::RegisterCategoryIfRequired(
+bool ContentSuggestionsService::TryRegisterProviderForCategory(
     ContentSuggestionsProvider* provider,
     Category category) {
   auto it = providers_by_category_.find(category);
   if (it != providers_by_category_.end()) {
     DCHECK_EQ(it->second, provider);
     return false;
   }
 
   auto dismissed_it = dismissed_providers_by_category_.find(category);
   if (dismissed_it != dismissed_providers_by_category_.end()) {
-    DCHECK_EQ(dismissed_it->second, provider);
-    dismissed_providers_by_category_.erase(dismissed_it);
+    // The initialisation of dismissed categories registers them with |nullptr|
+    // for providers, we need to check for that to see if the provider is
+    // already registered or not.
+    if (!dismissed_it->second) {
+      dismissed_it->second = provider;
+    } else {
+      DCHECK_EQ(dismissed_it->second, provider);
+    }
+    return false;
   }
 
+  RegisterCategory(category, provider);
+  return true;
+}
+
+void ContentSuggestionsService::RegisterCategory(
+    Category category,
+    ContentSuggestionsProvider* provider) {
+  DCHECK(!base::ContainsKey(providers_by_category_, category));
+  DCHECK(!IsCategoryDismissed(category));
+
   providers_by_category_[category] = provider;
   categories_.push_back(category);
   SortCategories();
   if (IsCategoryStatusAvailable(provider->GetCategoryStatus(category))) {
     suggestions_by_category_.insert(
         std::make_pair(category, std::vector<ContentSuggestion>()));
   }
-  return true;
+}
+
+void ContentSuggestionsService::UnregisterCategory(
+    Category category,
+    ContentSuggestionsProvider* provider) {
+  auto providers_it = providers_by_category_.find(category);
+  if (providers_it == providers_by_category_.end()) {
+    DCHECK(IsCategoryDismissed(category));
+    return;
+  }
+
+  DCHECK_EQ(provider, providers_it->second);
+  providers_by_category_.erase(providers_it);
+  categories_.erase(
+      std::find(categories_.begin(), categories_.end(), category));
+  suggestions_by_category_.erase(category);
 }
 
 bool ContentSuggestionsService::RemoveSuggestionByID(
     const ContentSuggestion::ID& suggestion_id) {
   std::vector<ContentSuggestion>* suggestions =
       &suggestions_by_category_[suggestion_id.category()];
   auto position =
       std::find_if(suggestions->begin(), suggestions->end(),
                    [&suggestion_id](const ContentSuggestion& suggestion) {
                      return suggestion_id == suggestion.id();
@@ skipping 29 matching lines @@
         if (bookmarks_empty) {
           if (left.IsKnownCategory(KnownCategories::BOOKMARKS))
             return false;
           if (right.IsKnownCategory(KnownCategories::BOOKMARKS))
             return true;
         }
         return category_factory_.CompareCategories(left, right);
       });
 }
 
+bool ContentSuggestionsService::IsCategoryDismissed(Category category) const {
+  return base::ContainsKey(dismissed_providers_by_category_, category);
+}
+
+void ContentSuggestionsService::RestoreDismissedCategory(Category category) {
+  auto dismissed_it = dismissed_providers_by_category_.find(category);
+  DCHECK(base::ContainsKey(dismissed_providers_by_category_, category));
+
+  // Keep the reference to the provider and remove it from the dismissed ones,
+  // because the category registration enforces that it's not dismissed.
+  ContentSuggestionsProvider* provider = dismissed_it->second;
+  dismissed_providers_by_category_.erase(dismissed_it);
+
+  if (provider)
+    RegisterCategory(category, provider);
+}
+
+void ContentSuggestionsService::RestoreDismissedCategoriesFromPrefs() {
+  // This must only be called at startup.
+  DCHECK(dismissed_providers_by_category_.empty());
+  DCHECK(providers_by_category_.empty());
+
+  const base::ListValue* list =
+      pref_service_->GetList(prefs::kDismissedCategories);
+  for (const std::unique_ptr<base::Value>& entry : *list) {
+    int id = 0;
+    if (!entry->GetAsInteger(&id)) {
+      DLOG(WARNING) << "Invalid category pref value: " << *entry;
+      continue;
+    }
+
+    // When the provider is registered, it will be stored in this map.
+    dismissed_providers_by_category_[category_factory()->FromIDValue(id)] =
+        nullptr;
+  }
+}
+
+void ContentSuggestionsService::StoreDismissedCategoriesToPrefs() {
+  base::ListValue list;
+  for (const auto& category_provider_pair : dismissed_providers_by_category_) {
+    list.AppendInteger(category_provider_pair.first.id());
+  }
+
+  pref_service_->Set(prefs::kDismissedCategories, list);
+}
+
 }  // namespace ntp_snippets