New snippets now replace old snippets and do not merge

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 <set>
 #include <utility>
@@ skipping 16 matching lines @@
       user_classifier_(pref_service) {
   // Can be null in tests.
   if (history_service)
     history_service_observer_.Add(history_service);
 }
 
 ContentSuggestionsService::~ContentSuggestionsService() {}
 
 void ContentSuggestionsService::Shutdown() {
   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 {
@@ skipping 20 matching lines @@
 ContentSuggestionsService::GetSuggestionsForCategory(Category category) const {
   auto iterator = suggestions_by_category_.find(category);
   if (iterator == suggestions_by_category_.end())
     return no_suggestions_;
   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;
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, gfx::Image()));
-    return;
-  }
-  Category category = id_category_map_.at(suggestion_id);
+  Category category = category_factory_.GetCategoryFromUniqueID(suggestion_id);
   if (!providers_by_category_.count(category)) {
     LOG(WARNING) << "Requested image for suggestion " << suggestion_id
                  << " for unavailable category " << category;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, gfx::Image()));
     return;
   }
   providers_by_category_[category]->FetchSuggestionImage(suggestion_id,
                                                          callback);
 }
 
 void ContentSuggestionsService::ClearHistory(
     base::Time begin,
     base::Time end,
     const base::Callback<bool(const GURL& url)>& filter) {
   for (const auto& provider : providers_) {
     provider->ClearHistory(begin, end, filter);
   }
 }
 
 void ContentSuggestionsService::ClearAllCachedSuggestions() {
   suggestions_by_category_.clear();
-  id_category_map_.clear();
   for (const auto& category_provider_pair : providers_by_category_) {
     category_provider_pair.second->ClearCachedSuggestions(
         category_provider_pair.first);
     FOR_EACH_OBSERVER(Observer, observers_,
                       OnNewSuggestions(category_provider_pair.first));
   }
 }
 
-void ContentSuggestionsService::ClearCachedSuggestions(
-    Category category) {
-  for (const ContentSuggestion& suggestion :
-       suggestions_by_category_[category]) {
-    id_category_map_.erase(suggestion.id());
-  }
+void ContentSuggestionsService::ClearCachedSuggestions(Category category) {
   suggestions_by_category_[category].clear();
   auto iterator = providers_by_category_.find(category);
   if (iterator != providers_by_category_.end())
     iterator->second->ClearCachedSuggestions(category);
 }
 
 void ContentSuggestionsService::GetDismissedSuggestionsForDebugging(
     Category category,
     const DismissedSuggestionsCallback& callback) {
   auto iterator = providers_by_category_.find(category);
   if (iterator != providers_by_category_.end())
     iterator->second->GetDismissedSuggestionsForDebugging(category, callback);
   else
     callback.Run(std::vector<ContentSuggestion>());
 }
 
 void ContentSuggestionsService::ClearDismissedSuggestionsForDebugging(
     Category category) {
   auto iterator = providers_by_category_.find(category);
   if (iterator != providers_by_category_.end())
     iterator->second->ClearDismissedSuggestionsForDebugging(category);
 }
 
 void ContentSuggestionsService::DismissSuggestion(
     const std::string& suggestion_id) {
-  if (!id_category_map_.count(suggestion_id)) {
-    LOG(WARNING) << "Dismissed unknown suggestion " << suggestion_id;
-    return;
-  }
-  Category category = id_category_map_.at(suggestion_id);
+  Category category = category_factory_.GetCategoryFromUniqueID(suggestion_id);
   if (!providers_by_category_.count(category)) {
     LOG(WARNING) << "Dismissed suggestion " << suggestion_id
                  << " for unavailable category " << category;
     return;
   }
   providers_by_category_[category]->DismissSuggestion(suggestion_id);
 
   // Remove the suggestion locally.
   bool removed = RemoveSuggestionByID(category, suggestion_id);
   DCHECK(removed) << "The dismissed suggestion " << suggestion_id
@@ skipping 31 matching lines @@
 void ContentSuggestionsService::OnNewSuggestions(
     ContentSuggestionsProvider* provider,
     Category category,
     std::vector<ContentSuggestion> new_suggestions) {
   if (RegisterCategoryIfRequired(provider, category))
     NotifyCategoryStatusChanged(category);
 
   if (!IsCategoryStatusAvailable(provider->GetCategoryStatus(category)))
     return;
 
-  for (const ContentSuggestion& suggestion :
-       suggestions_by_category_[category]) {
-    id_category_map_.erase(suggestion.id());
-  }
-
-  for (const ContentSuggestion& suggestion : new_suggestions)
-    id_category_map_.insert(std::make_pair(suggestion.id(), category));
-
   suggestions_by_category_[category] = std::move(new_suggestions);
 
   // The positioning of the bookmarks category depends on whether it's empty.
   // TODO(treib): Remove this temporary hack, crbug.com/640568.
   if (category.IsKnownCategory(KnownCategories::BOOKMARKS))
     SortCategories();
 
   FOR_EACH_OBSERVER(Observer, observers_, OnNewSuggestions(category));
 }
 
 void ContentSuggestionsService::OnCategoryStatusChanged(
     ContentSuggestionsProvider* provider,
     Category category,
     CategoryStatus new_status) {
   if (!IsCategoryStatusAvailable(new_status)) {
-    for (const ContentSuggestion& suggestion :
-         suggestions_by_category_[category]) {
-      id_category_map_.erase(suggestion.id());
-    }
     suggestions_by_category_.erase(category);
   }
   if (new_status == CategoryStatus::NOT_PROVIDED) {
     DCHECK(providers_by_category_.find(category) !=
            providers_by_category_.end());
     DCHECK_EQ(provider, providers_by_category_.find(category)->second);
     DismissCategory(category);
   } else {
     RegisterCategoryIfRequired(provider, category);
     DCHECK_EQ(new_status, provider->GetCategoryStatus(category));
@@ skipping 71 matching lines @@
   if (IsCategoryStatusAvailable(provider->GetCategoryStatus(category))) {
     suggestions_by_category_.insert(
         std::make_pair(category, std::vector<ContentSuggestion>()));
   }
   return true;
 }
 
 bool ContentSuggestionsService::RemoveSuggestionByID(
     Category category,
     const std::string& suggestion_id) {
-  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();
                    });
   if (position == suggestions->end())
     return false;
   suggestions->erase(position);
@@ skipping 26 matching lines @@
           if (left.IsKnownCategory(KnownCategories::BOOKMARKS))
             return false;
           if (right.IsKnownCategory(KnownCategories::BOOKMARKS))
             return true;
         }
         return category_factory_.CompareCategories(left, right);
       });
 }
 
 }  // namespace ntp_snippets