Add ContentSuggestionsService

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 {
+
+ContentSuggestionsService::ContentSuggestionsService(State enabled)
+    : enabled_(enabled) {}
+
+ContentSuggestionsService::~ContentSuggestionsService() {}
+
+void ContentSuggestionsService::Shutdown() {
+  DCHECK(providers_.empty());
+  DCHECK(categories_.empty());
+  DCHECK(suggestions_by_category_.empty());
+  DCHECK(id_category_map_.empty());
+  enabled_ = State::DISABLED;
+  FOR_EACH_OBSERVER(Observer, observers_, ContentSuggestionsServiceShutdown());
+  observers_.Clear();
+}
+
+ContentSuggestionsCategoryStatus ContentSuggestionsService::GetCategoryStatus(
+    ContentSuggestionsCategory category) const {
+  if (enabled_ == State::DISABLED)
+    return ContentSuggestionsCategoryStatus::
+        ALL_SUGGESTIONS_EXPLICITLY_DISABLED;
+
+  auto iterator = providers_.find(category);
+  if (iterator == providers_.end())
+    return ContentSuggestionsCategoryStatus::NOT_PROVIDED;
+
+  return iterator->second->GetCategoryStatus(category);
+}
+
+const std::vector<ContentSuggestion>&
+ContentSuggestionsService::GetSuggestionsForCategory(
+    ContentSuggestionsCategory category) const {
+  auto iterator = suggestions_by_category_.find(category);
+  if (iterator == suggestions_by_category_.end()) {
+    return no_suggestions_;

[tschumann, 2016/07/06 06:36:12]

I wonder if handing out references to the underlying data is the right thing to
do...
Essentially, you're giving out a live view of the data (actually ,the data
itself), so if new data arrives, users of this service would already see the
changes before they get notified. Even worse, data can be invalidated.
I guess that practically, this shouldn't be a real issue because copies need to
be made at the JNI bridge anyways, but that's more of a lucky circumstance.
IMO, the cleaner approach would be to hand out a copy of the data -- you also
wouldn't have to care about keeping the no_suggestions_ member around.
For typical use cases (where the client would want to store a copy anyways),
return-value-optimization or move semantics would kick in. In the JNI case,
you'd likely cause another copy, but honestly, copying such a vector shouldn't
be too much of an overhead.

[Marc Treib, 2016/07/06 08:20:44]

Generally, the convention is that a reference is something you shouldn't keep
around - you can use it right now, but then you should drop it. As such, I'm
fine with handing out references (but I also won't insist, if you feel
strongly).

[Philipp Keck, 2016/07/06 15:53:20]

Acknowledged.

+  }
+  return iterator->second;
+}
+
+void ContentSuggestionsService::FetchSuggestionImage(
+    const std::string& suggestion_id,
+    const ImageFetchedCallback& callback) {
+  if (!id_category_map_.count(suggestion_id)) {
+    LOG(WARNING) << "Requested image for unknown suggestion " << suggestion_id;
+    callback.Run(suggestion_id, gfx::Image());
+    return;
+  }
+  ContentSuggestionsCategory category = id_category_map_[suggestion_id];
+  if (!providers_.count(category)) {
+    LOG(WARNING) << "Requested image for suggestion " << suggestion_id
+                 << " for unavailable category " << int(category);
+    callback.Run(suggestion_id, gfx::Image());
+    return;
+  }
+  providers_[category]->FetchSuggestionImage(suggestion_id, callback);
+}
+
+void ContentSuggestionsService::ClearCachedSuggestionsForDebugging() {
+  suggestions_by_category_.clear();
+  id_category_map_.clear();
+  for (auto& provider : providers_) {
+    provider.second->ClearCachedSuggestionsForDebugging();
+  }
+  FOR_EACH_OBSERVER(Observer, observers_, OnNewSuggestions());
+}
+
+void ContentSuggestionsService::ClearDiscardedSuggestionsForDebugging() {
+  for (auto& provider : providers_) {
+    provider.second->ClearDiscardedSuggestionsForDebugging();
+  }
+}
+
+void ContentSuggestionsService::DiscardSuggestion(
+    const std::string& suggestion_id) {
+  if (!id_category_map_.count(suggestion_id)) {
+    LOG(WARNING) << "Discarded unknown suggestion " << suggestion_id;
+    return;
+  }
+  ContentSuggestionsCategory category = id_category_map_[suggestion_id];
+  if (!providers_.count(category)) {
+    LOG(WARNING) << "Discarded suggestion " << suggestion_id
+                 << " for unavailable category " << int(category);
+    return;
+  }
+  providers_[category]->DiscardSuggestion(suggestion_id);
+
+  // Remove the suggestion locally.
+  id_category_map_.erase(suggestion_id);
+  std::vector<ContentSuggestion>* suggestions =
+      &suggestions_by_category_[category];
+  auto position =
+      std::find_if(suggestions->begin(), suggestions->end(),
+                   [&suggestion_id](const ContentSuggestion& suggestion) {
+                     return suggestion_id == suggestion.id();
+                   });
+  DCHECK(position != suggestions->end());
+  suggestions->erase(position);
+}
+
+void ContentSuggestionsService::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ContentSuggestionsService::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void ContentSuggestionsService::RegisterProvider(
+    ContentSuggestionsProvider* provider) {
+  if (enabled_ == State::DISABLED)
+    return;
+
+  for (ContentSuggestionsCategory category : provider->provided_categories()) {
+    DCHECK_EQ(0ul, providers_.count(category));
+    providers_[category] = provider;
+    // TODO(pke) In the future, make sure that the categories have some useful
+    // (maybe constant, at least consistent) ordering for the UI.
+    categories_.push_back(category);
+    if (IsContentSuggestionsCategoryStatusAvailable(
+            provider->GetCategoryStatus(category))) {
+      suggestions_by_category_[category] = std::vector<ContentSuggestion>();
+    }
+    provider->SetObserver(this);
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnCategoryStatusChanged(
+                          category, provider->GetCategoryStatus(category)));
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Private methods
+
+void ContentSuggestionsService::OnNewSuggestions(
+    ContentSuggestionsCategory changed_category,
+    std::vector<ContentSuggestion> new_suggestions) {
+  DCHECK(IsCategoryRegistered(changed_category));
+
+  for (const ContentSuggestion& suggestion :
+       suggestions_by_category_[changed_category]) {
+    id_category_map_.erase(suggestion.id());
+  }
+
+  for (const ContentSuggestion& suggestion : new_suggestions) {
+    id_category_map_[suggestion.id()] = changed_category;
+  }
+
+  suggestions_by_category_[changed_category] = std::move(new_suggestions);
+
+  FOR_EACH_OBSERVER(Observer, observers_, OnNewSuggestions());
+}
+
+void ContentSuggestionsService::OnCategoryStatusChanged(
+    ContentSuggestionsCategory changed_category,
+    ContentSuggestionsCategoryStatus new_status) {
+  if (!IsContentSuggestionsCategoryStatusAvailable(new_status)) {
+    for (const ContentSuggestion& suggestion :
+         suggestions_by_category_[changed_category]) {
+      id_category_map_.erase(suggestion.id());
+    }
+    suggestions_by_category_.erase(changed_category);
+  }
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnCategoryStatusChanged(changed_category, new_status));
+}
+
+void ContentSuggestionsService::OnProviderShutdown(
+    ContentSuggestionsProvider* provider) {
+  for (ContentSuggestionsCategory category : provider->provided_categories()) {
+    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_.erase(category);
+    FOR_EACH_OBSERVER(
+        Observer, observers_,
+        OnCategoryStatusChanged(category, GetCategoryStatus(category)));
+  }
+  provider->SetObserver(nullptr);
+}
+
+bool ContentSuggestionsService::IsCategoryRegistered(
+    ContentSuggestionsCategory category) const {
+  return std::find(categories_.begin(), categories_.end(), category) !=
+         categories_.end();
+}
+
+}  // namespace ntp_snippets