Combine all suggestions factories into ContentSuggestionsServiceFactory

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 "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/gfx/image/image.h"
 
 namespace ntp_snippets {
 
 bool ContentSuggestionsService::CompareCategoriesByID::operator()(
     const Category& left,
     const Category& right) const {
   return left.id() < right.id();
 }
 
 ContentSuggestionsService::ContentSuggestionsService(State state)
     : state_(state) {}
 
 ContentSuggestionsService::~ContentSuggestionsService() {}
 
 void ContentSuggestionsService::Shutdown() {
-  DCHECK(providers_by_category_.empty());
-  DCHECK(categories_.empty());
-  DCHECK(suggestions_by_category_.empty());
-  DCHECK(id_category_map_.empty());
+  ntp_snippets_service_ = nullptr;
+  id_category_map_.clear();
+  suggestions_by_category_.clear();
+  providers_by_category_.clear();
+  categories_.clear();
+  providers_.clear();
   state_ = State::DISABLED;
   FOR_EACH_OBSERVER(Observer, observers_, ContentSuggestionsServiceShutdown());
 }
 
 CategoryStatus ContentSuggestionsService::GetCategoryStatus(
     Category category) const {
   if (state_ == State::DISABLED) {
     return CategoryStatus::ALL_SUGGESTIONS_EXPLICITLY_DISABLED;
   }
 
@@ skipping 78 matching lines @@
 
 void ContentSuggestionsService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ContentSuggestionsService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ContentSuggestionsService::RegisterProvider(
-    ContentSuggestionsProvider* provider) {
-  // TODO(pke): When NTPSnippetsService is purely a provider, think about
-  // removing this state check.
-  if (state_ == State::DISABLED)
-    return;
-
-  provider->SetObserver(this);
+    std::unique_ptr<ContentSuggestionsProvider> provider) {
+  DCHECK(state_ == State::ENABLED);
   for (Category category : provider->GetProvidedCategories()) {
     DCHECK_NE(CategoryStatus::NOT_PROVIDED,
               provider->GetCategoryStatus(category));
-    RegisterCategoryIfRequired(provider, category);
+    RegisterCategoryIfRequired(provider.get(), category);
     NotifyCategoryStatusChanged(category);
   }
+  providers_.push_back(std::move(provider));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Private methods
 
 void ContentSuggestionsService::OnNewSuggestions(
     ContentSuggestionsProvider* provider,
     Category category,
     std::vector<ContentSuggestion> new_suggestions) {
   if (RegisterCategoryIfRequired(provider, category)) {
@@ skipping 32 matching lines @@
     providers_by_category_.erase(providers_it);
     categories_.erase(
         std::find(categories_.begin(), categories_.end(), category));
   } else {
     RegisterCategoryIfRequired(provider, category);
     DCHECK_EQ(new_status, provider->GetCategoryStatus(category));
   }
   NotifyCategoryStatusChanged(category);
 }
 
-void ContentSuggestionsService::OnProviderShutdown(
-    ContentSuggestionsProvider* provider) {
-  for (Category category : provider->GetProvidedCategories()) {
-    auto iterator = std::find(categories_.begin(), categories_.end(), category);
-    DCHECK(iterator != categories_.end());
-    categories_.erase(iterator);
-    for (const ContentSuggestion& suggestion :
-         suggestions_by_category_[category]) {
-      id_category_map_.erase(suggestion.id());
-    }
-    suggestions_by_category_.erase(category);
-    providers_by_category_.erase(category);
-    NotifyCategoryStatusChanged(category);
-  }
-}
-
 bool ContentSuggestionsService::RegisterCategoryIfRequired(
     ContentSuggestionsProvider* provider,
     Category category) {
   auto it = providers_by_category_.find(category);
   if (it != providers_by_category_.end()) {
     DCHECK_EQ(it->second, provider);
     return false;
   }
 
   providers_by_category_[category] = provider;
   categories_.push_back(category);
   std::sort(categories_.begin(), categories_.end(),
             [this](const Category& left, const Category& right) {
               return category_factory_.CompareCategories(left, right);
             });
   if (IsCategoryStatusAvailable(provider->GetCategoryStatus(category))) {
     suggestions_by_category_.insert(
         std::make_pair(category, std::vector<ContentSuggestion>()));
   }
   return true;
 }
 
 void ContentSuggestionsService::NotifyCategoryStatusChanged(Category category) {
   FOR_EACH_OBSERVER(
       Observer, observers_,
       OnCategoryStatusChanged(category, GetCategoryStatus(category)));
 }
 
 }  // namespace ntp_snippets