Add ContentSuggestionsService

components/ntp_snippets/content_suggestions_service.cc

Index: components/ntp_snippets/content_suggestions_service.cc
diff --git a/components/ntp_snippets/content_suggestions_service.cc b/components/ntp_snippets/content_suggestions_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c2fc63dfa41a54951f88ab61650b14560c89daca
--- /dev/null
+++ b/components/ntp_snippets/content_suggestions_service.cc
@@ -0,0 +1,132 @@
+// 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 "base/observer_list.h"
+#include "ui/gfx/image/image.h"
+
+namespace ntp_snippets {
+
+ContentSuggestionsService::ContentSuggestionsService(bool enabled)
+    : enabled_(enabled) {
+  if (enabled_) {
+  }
+}
+
+ContentSuggestionsService::~ContentSuggestionsService() {}
+
+void ContentSuggestionsService::RegisterProvider(
+    ContentSuggestionsProvider* provider) {
+  DCHECK(providers_.count(provider->GetProviderType()) == 0);
+  providers_[provider->GetProviderType()] = provider;
+  provider->SetDelegate(this);
+}
+
+void ContentSuggestionsService::Shutdown() {
+  FOR_EACH_OBSERVER(ContentSuggestionsServiceObserver, observers_,
+                    ContentSuggestionsServiceShutdown());
+  observers_.Clear();
+  for (auto& provider : providers_) {
+    provider.second->SetDelegate(nullptr);
+  }
+  providers_.clear();
+  enabled_ = false;
+}
+
+void ContentSuggestionsService::FetchImage(
+    const ContentSuggestionsProviderType provider_type,
+    const std::string& suggestion_id,
+    const ImageFetchedCallback& callback) {
+  if (providers_.count(provider_type)) {
+    providers_[provider_type]->FetchImage(suggestion_id, callback);
+  } else {
+    LOG(WARNING) << "Requested image for suggestion" << suggestion_id
+                 << " for unavailable provider type "
+                 << static_cast<base::underlying_type<
+                        ContentSuggestionsProviderType>::type>(provider_type);
+    callback.Run(suggestion_id, gfx::Image());
+  }
+}
+
+void ContentSuggestionsService::ClearSuggestions() {
+  for (auto& provider : providers_) {
+    provider.second->ClearSuggestions();
+  }
+}
+
+void ContentSuggestionsService::ClearDiscardedSuggestions() {
+  for (auto& provider : providers_) {
+    provider.second->ClearDiscardedSuggestions();
+  }
+}
+
+void ContentSuggestionsService::Discard(
+    const ContentSuggestionsProviderType provider_type,
+    const std::string& suggestion_id) {
+  if (providers_.count(provider_type)) {
+    providers_[provider_type]->Discard(suggestion_id);
+  } else {
+    LOG(WARNING) << "Discarded suggestion " << suggestion_id
+                 << " for unavailable provider type "
+                 << static_cast<base::underlying_type<
+                        ContentSuggestionsProviderType>::type>(provider_type);
+  }
+}
+
+void ContentSuggestionsService::AddObserver(
+    ContentSuggestionsServiceObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ContentSuggestionsService::RemoveObserver(
+    ContentSuggestionsServiceObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void ContentSuggestionsService::OnSuggestionsChanged(
+    const ContentSuggestionsProvider& source,
+    ContentSuggestionCategory changed_category,
+    std::vector<ContentSuggestion> new_suggestions) {
+  RemoveSuggestionsOfProvider(&suggestions_[changed_category],
+                              source.GetProviderType());
+
+  std::move(new_suggestions.begin(), new_suggestions.end(),
+            std::back_inserter(suggestions_[changed_category]));
+
+  FOR_EACH_OBSERVER(ContentSuggestionsServiceObserver, observers_,
+                    OnSuggestionsChanged(changed_category));
+}
+
+void ContentSuggestionsService::OnProviderShutdown(
+    const ContentSuggestionsProvider& source) {
+  for (auto& pair : suggestions_) {
+    if (RemoveSuggestionsOfProvider(&pair.second, source.GetProviderType())) {
+      FOR_EACH_OBSERVER(ContentSuggestionsServiceObserver, observers_,
+                        OnSuggestionsChanged(pair.first));
+    }
+  }
+  providers_.erase(source.GetProviderType());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Private methods
+
+bool ContentSuggestionsService::RemoveSuggestionsOfProvider(
+    std::vector<ContentSuggestion>* list,
+    ContentSuggestionsProviderType provider_type) {
+  auto provider_matcher = [provider_type](const ContentSuggestion& s) {
+    return s.provider() == provider_type;
+  };
+  auto remove_from =
+      std::remove_if(list->begin(), list->end(), provider_matcher);
+  if (remove_from == list->end()) {
+    return false;
+  } else {
+    list->erase(remove_from, list->end());
+    return true;
+  }
+}
+
+}  // namespace ntp_snippets