📰 Let the backend trigger sign in related refreshes

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/callbacks.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"
+#include "components/signin/core/browser/signin_manager.h"
 
 class PrefService;
 class PrefRegistrySimple;
 
 namespace ntp_snippets {
 
 class RemoteSuggestionsProvider;
 
 // Retrieves suggestions from a number of ContentSuggestionsProviders and serves
 // them grouped into categories. There can be at most one provider per category.
 class ContentSuggestionsService : public KeyedService,
                                   public ContentSuggestionsProvider::Observer,
+                                  public SigninManagerBase::Observer,
                                   public history::HistoryServiceObserver {
  public:
   class Observer {
    public:
     // Fired every time the service receives a new set of data for the given
     // |category|, replacing any previously available data (though in most cases
     // there will be an overlap and only a few changes within the data). The new
     // data is then available through |GetSuggestionsForCategory(category)|.
     virtual void OnNewSuggestions(Category category) = 0;
 
     // Fired when the status of a suggestions category changed. When the status
     // changes to an unavailable status, the suggestions of the respective
     // category have been invalidated, which means that they must no longer be
     // displayed to the user. The UI must immediately clear any suggestions of
     // that category.
     virtual void OnCategoryStatusChanged(Category category,
                                          CategoryStatus new_status) = 0;
 
     // Fired when a suggestion has been invalidated. The UI must immediately
     // clear the suggestion even from open NTPs. Invalidation happens, for
     // example, when the content that the suggestion refers to is gone.
     // Note that this event may be fired even if the corresponding category is
     // not currently AVAILABLE, because open UIs may still be showing the
     // suggestion that is to be removed. This event may also be fired for
     // |suggestion_id|s that never existed and should be ignored in that case.
     virtual void OnSuggestionInvalidated(
         const ContentSuggestion::ID& suggestion_id) = 0;
 
+    // Fired when the previously sent data is not valid anymore and a refresh
+    // of all the suggestions is required. Called for example when the sign in
+    // state changes and personalised suggestions have to be shown or discarded.
+    virtual void OnFullRefreshRequired() = 0;
+
     // Sent when the service is shutting down. After the service has shut down,
     // it will not provide any data anymore, though calling the getters is still
     // safe.
     virtual void ContentSuggestionsServiceShutdown() = 0;
 
    protected:
     virtual ~Observer() = default;
   };
 
   enum State {
     ENABLED,
     DISABLED,
   };
 
   ContentSuggestionsService(State state,
+                            SigninManagerBase* signin_manager,
                             history::HistoryService* history_service,
                             PrefService* pref_service);
   ~ContentSuggestionsService() override;
 
   // Inherited from KeyedService.
   void Shutdown() override;
 
   static void RegisterProfilePrefs(PrefRegistrySimple* registry);
 
   State state() { return state_; }
@@ skipping 112 matching lines @@
   void OnNewSuggestions(ContentSuggestionsProvider* provider,
                         Category category,
                         std::vector<ContentSuggestion> suggestions) override;
   void OnCategoryStatusChanged(ContentSuggestionsProvider* provider,
                                Category category,
                                CategoryStatus new_status) override;
   void OnSuggestionInvalidated(
       ContentSuggestionsProvider* provider,
       const ContentSuggestion::ID& suggestion_id) override;
 
+  // SigninManagerBase::Observer implementation
+  void GoogleSigninSucceeded(const std::string& account_id,
+                             const std::string& username,
+                             const std::string& password) override;
+  void GoogleSignedOut(const std::string& account_id,
+                       const std::string& username) override;
+
   // history::HistoryServiceObserver implementation.
   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 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 OnSignInStateChanged();
+
   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_;
@@ skipping 23 matching lines @@
   // |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 SigninManager. All observers are notified when the signin
+  // state changes so that they can refresh their list of suggestions.
+  ScopedObserver<SigninManagerBase, SigninManagerBase::Observer>
+      signin_observer_;
+
   // 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
   // RemoteSuggestionsProvider is loaded, it is also present in |providers_|,
   // otherwise this is a nullptr.
   RemoteSuggestionsProvider* 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_