Combine all suggestions factories into ContentSuggestionsServiceFactory

components/ntp_snippets/content_suggestions_provider.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_PROVIDER_H_
 #define COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_PROVIDER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "components/ntp_snippets/category.h"
 #include "components/ntp_snippets/category_status.h"
 #include "components/ntp_snippets/content_suggestion.h"
 
 namespace gfx {
 class Image;
 }
 
 namespace ntp_snippets {
 
 // Provides content suggestions from one particular source.
 // A provider can provide suggestions for multiple ContentSuggestionCategories,
 // but for every category that it provides, it will be the only provider in the
 // system which provides suggestions for that category.
-// A provider can be a keyed service, in which case it should notify the
-// ContentSuggestionsService through the observer before it shuts down.
+// Providers are created by the ContentSuggestionsServiceFactory and owned and
+// shut down by the ContentSuggestionsService.
 class ContentSuggestionsProvider {
  public:
   using ImageFetchedCallback =
       base::Callback<void(const std::string& suggestion_id, const gfx::Image&)>;
 
   // The observer of a provider is notified when new data is available.
   class Observer {
    public:
     // Called when the available content changed.
     // If a provider provides suggestions for multiple categories, this callback
@@ skipping 18 matching lines @@
     // If |new_status| is any other value, it must match the value that is
     // currently returned from the provider's |GetCategoryStatus(category)|. In
     // case the given |category| is not known yet, the calling |provider| will
     // be registered as its provider. Whenever the status changes to an
     // unavailable status, all suggestions in that category must immediately be
     // removed from all caches and from the UI, but the provider remains
     // registered.
     virtual void OnCategoryStatusChanged(ContentSuggestionsProvider* provider,
                                          Category category,
                                          CategoryStatus new_status) = 0;
-
-    // Called when the provider needs to shut down and will not deliver any
-    // suggestions anymore.
-    virtual void OnProviderShutdown(ContentSuggestionsProvider* provider) = 0;
   };
 
-  // Sets an observer which is notified about changes to the available
-  // suggestions, or removes it by passing a nullptr. The provider does not take
-  // ownership of the observer and the observer must outlive this provider.
-  virtual void SetObserver(Observer* observer) = 0;
+  virtual ~ContentSuggestionsProvider();
 
   // Returns the categories provided by this provider.
   // When the set of provided categories changes, the Observer is notified
   // through |OnNewSuggestions| or |OnCategoryStatusChanged| for added
   // categories, and through |OnCategoryStatusChanged| with parameter
   // NOT_PROVIDED for removed categories.
   virtual std::vector<Category> GetProvidedCategories() = 0;
 
   // Determines the status of the given |category|, see CategoryStatus.
   virtual CategoryStatus GetCategoryStatus(Category category) = 0;
@@ skipping 15 matching lines @@
   // fetch starts from scratch.
   virtual void ClearCachedSuggestionsForDebugging() = 0;
 
   // Used only for debugging purposes. Clears the cache of dismissed
   // suggestions, if present, so that no suggestions are suppressed. This does
   // not necessarily make previously dismissed suggestions reappear, as they may
   // have been permanently deleted, depending on the provider implementation.
   virtual void ClearDismissedSuggestionsForDebugging() = 0;
 
  protected:
-  ContentSuggestionsProvider(CategoryFactory* category_factory);
-  virtual ~ContentSuggestionsProvider();
+  ContentSuggestionsProvider(Observer* observer,
+                             CategoryFactory* category_factory);
 
   // Creates a unique ID. The given |within_category_id| must be unique among
   // all suggestion IDs from this provider for the given |category|. This method
   // combines it with the |category| to form an ID that is unique
   // application-wide, because this provider is the only one that provides
   // suggestions for that category.
   std::string MakeUniqueID(Category category,
                            const std::string& within_category_id);
+
   // Reverse functions for MakeUniqueID()
   Category GetCategoryFromUniqueID(const std::string& unique_id);
   std::string GetWithinCategoryIDFromUniqueID(const std::string& unique_id);
 
+  Observer* observer() const { return observer_; }
   CategoryFactory* category_factory() const { return category_factory_; }
 
  private:
+  Observer* observer_;
   CategoryFactory* category_factory_;
 };
 
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_PROVIDER_H_