📰 Persist category dismissals

components/ntp_snippets/content_suggestions_service.h

 // 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.
 
 #ifndef COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_SERVICE_H_
 #define COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_SERVICE_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/observer_list.h"
 #include "base/optional.h"
 #include "base/scoped_observer.h"
 #include "base/time/time.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/ntp_snippets/category_factory.h"
 #include "components/ntp_snippets/category_status.h"
 #include "components/ntp_snippets/content_suggestions_provider.h"
 #include "components/ntp_snippets/user_classifier.h"
 
 class PrefService;
+class PrefRegistrySimple;
 
 namespace gfx {
 class Image;
 }  // namespace gfx
 
 namespace ntp_snippets {
 
 class NTPSnippetsService;
 
 // Retrieves suggestions from a number of ContentSuggestionsProviders and serves
@@ skipping 47 matching lines @@
   };
 
   ContentSuggestionsService(State state,
                             history::HistoryService* history_service,
                             PrefService* pref_service);
   ~ContentSuggestionsService() override;
 
   // Inherited from KeyedService.
   void Shutdown() override;
 
+  static void RegisterProfilePrefs(PrefRegistrySimple* registry);
+
   State state() { return state_; }
 
   // Gets all categories for which a provider is registered. The categories
   // may or may not be available, see |GetCategoryStatus()|.
   const std::vector<Category>& GetCategories() const { return categories_; }
 
   // Gets the status of a category.
   CategoryStatus GetCategoryStatus(Category category) const;
 
   // Gets the meta information of a category.
@@ skipping 17 matching lines @@
   void DismissSuggestion(const ContentSuggestion::ID& suggestion_id);
 
   // Dismisses the given |category|, if it exists.
   // This will not trigger an update through the observers.
   void DismissCategory(Category category);
 
   // Restores all dismissed categories.
   // This will not trigger an update through the observers.
   void RestoreDismissedCategories();
 
+  // Returns whether |category| is dismissed.
+  bool IsCategoryDismissed(Category category) const;
+
   // Observer accessors.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Registers a new ContentSuggestionsProvider. It must be ensured that at most
   // one provider is registered for every category and that this method is
   // called only once per provider.
   void RegisterProvider(std::unique_ptr<ContentSuggestionsProvider> provider);
 
   // Removes history from the specified time range where the URL matches the
@@ skipping 63 matching lines @@
   void OnURLsDeleted(history::HistoryService* history_service,
                      bool all_history,
                      bool expired,
                      const history::URLRows& deleted_rows,
                      const std::set<GURL>& favicon_urls) override;
   void HistoryServiceBeingDeleted(
       history::HistoryService* history_service) override;
 
   // Registers the given |provider| for the given |category|, unless it is
   // already registered. Returns true if the category was newly registered or
-  // false if it was present before.
-  bool RegisterCategoryIfRequired(ContentSuggestionsProvider* provider,
-                                  Category category);
+  // false if it is dismissed or was present before.
+  bool TryRegisterProviderForCategory(ContentSuggestionsProvider* provider,
+                                      Category category);
+  void RegisterCategory(Category category,
+                        ContentSuggestionsProvider* provider);
+  void UnregisterCategory(Category category,
+                          ContentSuggestionsProvider* provider);
 
   // Removes a suggestion from the local store |suggestions_by_category_|, if it
   // exists. Returns true if a suggestion was removed.
   bool RemoveSuggestionByID(const ContentSuggestion::ID& suggestion_id);
 
   // Fires the OnCategoryStatusChanged event for the given |category|.
   void NotifyCategoryStatusChanged(Category category);
 
   void SortCategories();
 
+  // Re-enables a dismissed category, making querying its provider possible.
+  void RestoreDismissedCategory(Category category);
+
+  void RestoreDismissedCategoriesFromPrefs();
+  void StoreDismissedCategoriesToPrefs();
+
   // Whether the content suggestions feature is enabled.
   State state_;
 
   // Provides new and existing categories and an order for them.
   CategoryFactory category_factory_;
 
   // All registered providers, owned by the service.
   std::vector<std::unique_ptr<ContentSuggestionsProvider>> providers_;
 
   // All registered categories and their providers. A provider may be contained
   // multiple times, if it provides multiple categories. The keys of this map
   // are exactly the entries of |categories_| and the values are a subset of
   // |providers_|.
   std::map<Category, ContentSuggestionsProvider*, Category::CompareByID>
       providers_by_category_;
 
   // All dismissed categories and their providers. These may be restored by
-  // RestoreDismissedCategories().
+  // RestoreDismissedCategories(). The provider can be null if the dismissed
+  // category has received no updates since initialisation.
+  // (see RestoreDismissedCategoriesFromPrefs())
   std::map<Category, ContentSuggestionsProvider*, Category::CompareByID>
       dismissed_providers_by_category_;
 
   // All current suggestion categories, in an order determined by the
   // |category_factory_|. This vector contains exactly the same categories as
   // |providers_by_category_|.
   std::vector<Category> categories_;
 
   // All current suggestions grouped by category. This contains an entry for
   // every category in |categories_| whose status is an available status. It may
   // contain an empty vector if the category is available but empty (or still
   // loading).
   std::map<Category, std::vector<ContentSuggestion>, Category::CompareByID>
       suggestions_by_category_;
 
   // Observer for the HistoryService. All providers are notified when history is
   // deleted.
   ScopedObserver<history::HistoryService, history::HistoryServiceObserver>
       history_service_observer_;
 
   base::ObserverList<Observer> observers_;
 
   const std::vector<ContentSuggestion> no_suggestions_;
 
   // Keep a direct reference to this special provider to redirect scheduling,
   // background fetching and debugging calls to it. If the NTPSnippetsService is
   // loaded, it is also present in |providers_|, otherwise this is a nullptr.
   NTPSnippetsService* ntp_snippets_service_;
 
+  PrefService* pref_service_;
+
   UserClassifier user_classifier_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSuggestionsService);
 };
 
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_SERVICE_H_