Add ContentSuggestionsCategoryFactory; Store categories as ints

components/ntp_snippets/ntp_snippets_service.cc

 // Copyright 2015 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/ntp_snippets_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 169 matching lines @@
           [](const std::unique_ptr<NTPSnippet>& snippet) { return !snippet; }),
       snippets->end());
 }
 
 }  // namespace
 
 NTPSnippetsService::NTPSnippetsService(
     bool enabled,
     PrefService* pref_service,
     SuggestionsService* suggestions_service,
+    ContentSuggestionsCategoryFactory* category_factory,
     const std::string& application_language_code,
     NTPSnippetsScheduler* scheduler,
     std::unique_ptr<NTPSnippetsFetcher> snippets_fetcher,
     std::unique_ptr<ImageFetcher> image_fetcher,
     std::unique_ptr<ImageDecoder> image_decoder,
     std::unique_ptr<NTPSnippetsDatabase> database,
     std::unique_ptr<NTPSnippetsStatusService> status_service)
-    : ContentSuggestionsProvider({ContentSuggestionsCategory::ARTICLES}),
+    : ContentSuggestionsProvider(category_factory),
       state_(State::NOT_INITED),
       category_status_(ContentSuggestionsCategoryStatus::INITIALIZING),
       pref_service_(pref_service),
       suggestions_service_(suggestions_service),
       application_language_code_(application_language_code),
       observer_(nullptr),
       scheduler_(scheduler),
       snippets_fetcher_(std::move(snippets_fetcher)),
       image_fetcher_(std::move(image_fetcher)),
       image_decoder_(std::move(image_decoder)),
       database_(std::move(database)),
       snippets_status_service_(std::move(status_service)),
-      fetch_after_load_(false) {
+      fetch_after_load_(false),
+      provided_category_(category_factory->FromKnownCategory(
+          KnownSuggestionsCategories::ARTICLES)) {
   // In some cases, don't even bother loading the database.
   if (!enabled) {
     EnterState(State::SHUT_DOWN,
                ContentSuggestionsCategoryStatus::CATEGORY_EXPLICITLY_DISABLED);
     return;
   }
   if (database_->IsErrorState()) {
     EnterState(State::SHUT_DOWN,
                ContentSuggestionsCategoryStatus::LOADING_ERROR);
     return;
@@ skipping 50 matching lines @@
   if (ready()) {
     base::Time now = base::Time::Now();
     scheduler_->Schedule(
         GetFetchingIntervalWifiCharging(), GetFetchingIntervalWifi(now),
         GetFetchingIntervalFallback(), GetRescheduleTime(now));
   } else {
     scheduler_->Unschedule();
   }
 }
 
+std::vector<ContentSuggestionsCategory>
+NTPSnippetsService::GetProvidedCategories() {
+  return std::vector<ContentSuggestionsCategory>({provided_category_});
+}
+
 void NTPSnippetsService::FetchSuggestionImage(
     const std::string& suggestion_id,
     const ImageFetchedCallback& callback) {
   std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
   database_->LoadImage(
       snippet_id,
       base::Bind(&NTPSnippetsService::OnSnippetImageFetchedFromDatabase,
                  base::Unretained(this), snippet_id, callback));
 }
 
@@ skipping 53 matching lines @@
   database_->DeleteSnippets(dismissed_snippets_);
   dismissed_snippets_.clear();
 }
 
 void NTPSnippetsService::SetObserver(Observer* observer) {
   observer_ = observer;
 }
 
 ContentSuggestionsCategoryStatus NTPSnippetsService::GetCategoryStatus(
     ContentSuggestionsCategory category) {
-  DCHECK_EQ(ContentSuggestionsCategory::ARTICLES, category);
+  DCHECK(category.IsKnownCategory(KnownSuggestionsCategories::ARTICLES));
   return category_status_;
 }
 
 void NTPSnippetsService::AddObserver(NTPSnippetsServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void NTPSnippetsService::RemoveObserver(NTPSnippetsServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 252 matching lines @@
 
   // Fetching from the DB failed; start a network fetch.
   FetchSnippetImageFromNetwork(snippet_id, callback);
 }
 
 void NTPSnippetsService::OnSnippetImageDecoded(
     const std::string& snippet_id,
     const ImageFetchedCallback& callback,
     const gfx::Image& image) {
   if (!image.IsEmpty()) {
-    callback.Run(MakeUniqueID(ContentSuggestionsCategory::ARTICLES, snippet_id),
-                 image);
+    callback.Run(MakeUniqueID(provided_category_, snippet_id), image);
     return;
   }
 
   // If decoding the image failed, delete the DB entry.
   database_->DeleteImage(snippet_id);
 
   FetchSnippetImageFromNetwork(snippet_id, callback);
 }
 
 void NTPSnippetsService::FetchSnippetImageFromNetwork(
     const std::string& snippet_id,
     const ImageFetchedCallback& callback) {
   auto it =
       std::find_if(snippets_.begin(), snippets_.end(),
                    [&snippet_id](const std::unique_ptr<NTPSnippet>& snippet) {
                      return snippet->id() == snippet_id;
                    });
   if (it == snippets_.end()) {
-    callback.Run(MakeUniqueID(ContentSuggestionsCategory::ARTICLES, snippet_id),
-                 gfx::Image());
+    callback.Run(MakeUniqueID(provided_category_, snippet_id), gfx::Image());
     return;
   }
 
   const NTPSnippet& snippet = *it->get();
   image_fetcher_->StartOrQueueNetworkRequest(
       snippet.id(), snippet.salient_image_url(), callback);
 }
 
 void NTPSnippetsService::EnterStateEnabled(bool fetch_snippets) {
   if (fetch_snippets)
@@ skipping 120 matching lines @@
                     NTPSnippetsServiceLoaded());
 
   if (!observer_)
     return;
 
   std::vector<ContentSuggestion> result;
   for (const std::unique_ptr<NTPSnippet>& snippet : snippets_) {
     if (!snippet->is_complete())
       continue;
     ContentSuggestion suggestion(
-        MakeUniqueID(ContentSuggestionsCategory::ARTICLES, snippet->id()),
+        MakeUniqueID(provided_category_, snippet->id()),
         snippet->best_source().url);
     suggestion.set_amp_url(snippet->best_source().amp_url);
     suggestion.set_title(snippet->title());
     suggestion.set_snippet_text(snippet->snippet());
     suggestion.set_publish_date(snippet->publish_date());
     suggestion.set_publisher_name(snippet->best_source().publisher_name);
     suggestion.set_score(snippet->score());
     result.emplace_back(std::move(suggestion));
   }
-  observer_->OnNewSuggestions(ContentSuggestionsCategory::ARTICLES,
-                              std::move(result));
+  observer_->OnNewSuggestions(provided_category_, std::move(result));
 }
 
 void NTPSnippetsService::NotifyCategoryStatusChanged() {
   if (observer_) {
-    observer_->OnCategoryStatusChanged(ContentSuggestionsCategory::ARTICLES,
-                                       category_status_);
+    observer_->OnCategoryStatusChanged(provided_category_, category_status_);
   }
 }
 
 }  // namespace ntp_snippets