[NTP Snippets] Introduce ContentSuggestion::ID

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 54 matching lines @@
 
 const std::vector<ContentSuggestion>&
 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 ContentSuggestion::ID& suggestion_id,
     const ImageFetchedCallback& callback) {
-  Category category = category_factory_.GetCategoryFromUniqueID(suggestion_id);
-  if (!providers_by_category_.count(category)) {
+  if (!providers_by_category_.count(suggestion_id.category())) {
     LOG(WARNING) << "Requested image for suggestion " << suggestion_id
-                 << " for unavailable category " << category;
+                 << " for unavailable category " << suggestion_id.category();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, gfx::Image()));
     return;
   }
-  providers_by_category_[category]->FetchSuggestionImage(suggestion_id,
-                                                         callback);
+  providers_by_category_[suggestion_id.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);
   }
 }
@@ skipping 26 matching lines @@
 }
 
 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) {
-  Category category = category_factory_.GetCategoryFromUniqueID(suggestion_id);
-  if (!providers_by_category_.count(category)) {
+    const ContentSuggestion::ID& suggestion_id) {
+  if (!providers_by_category_.count(suggestion_id.category())) {
     LOG(WARNING) << "Dismissed suggestion " << suggestion_id
-                 << " for unavailable category " << category;
+                 << " for unavailable category " << suggestion_id.category();
     return;
   }
-  providers_by_category_[category]->DismissSuggestion(suggestion_id);
+  providers_by_category_[suggestion_id.category()]->DismissSuggestion(
+      suggestion_id);
 
   // Remove the suggestion locally.
-  bool removed = RemoveSuggestionByID(category, suggestion_id);
+  bool removed = RemoveSuggestionByID(suggestion_id);
   DCHECK(removed) << "The dismissed suggestion " << suggestion_id
                   << " has already been removed. Providers must not call"
                   << " OnNewSuggestions in response to DismissSuggestion.";
 }
 
 void ContentSuggestionsService::DismissCategory(Category category) {
   auto providers_it = providers_by_category_.find(category);
   if (providers_it == providers_by_category_.end())
     return;
 
@@ skipping 53 matching lines @@
     DismissCategory(category);
   } else {
     RegisterCategoryIfRequired(provider, category);
     DCHECK_EQ(new_status, provider->GetCategoryStatus(category));
   }
   NotifyCategoryStatusChanged(category);
 }
 
 void ContentSuggestionsService::OnSuggestionInvalidated(
     ContentSuggestionsProvider* provider,
-    Category category,
-    const std::string& suggestion_id) {
-  RemoveSuggestionByID(category, suggestion_id);
+    const ContentSuggestion::ID& suggestion_id) {
+  RemoveSuggestionByID(suggestion_id);
   FOR_EACH_OBSERVER(Observer, observers_,
-                    OnSuggestionInvalidated(category, suggestion_id));
+                    OnSuggestionInvalidated(suggestion_id));
 }
 
 // history::HistoryServiceObserver implementation.
 void ContentSuggestionsService::OnURLsDeleted(
     history::HistoryService* history_service,
     bool all_history,
     bool expired,
     const history::URLRows& deleted_rows,
     const std::set<GURL>& favicon_urls) {
   // We don't care about expired entries.
@@ skipping 48 matching lines @@
   categories_.push_back(category);
   SortCategories();
   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) {
+    const ContentSuggestion::ID& suggestion_id) {
   std::vector<ContentSuggestion>* suggestions =
-      &suggestions_by_category_[category];
+      &suggestions_by_category_[suggestion_id.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);
 
   // 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))
+  if (suggestion_id.category().IsKnownCategory(KnownCategories::BOOKMARKS))
     SortCategories();
 
   return true;
 }
 
 void ContentSuggestionsService::NotifyCategoryStatusChanged(Category category) {
   FOR_EACH_OBSERVER(
       Observer, observers_,
       OnCategoryStatusChanged(category, GetCategoryStatus(category)));
 }
@@ skipping 12 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