[NTP Snippets] Introduce ContentSuggestion::ID

components/ntp_snippets/offline_pages/offline_page_suggestions_provider.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/offline_pages/offline_page_suggestions_provider.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 117 matching lines @@
         /*show_if_empty=*/false);
   }
   NOTREACHED() << "Unknown category " << category.id();
   return CategoryInfo(base::string16(),
                       ContentSuggestionsCardLayout::MINIMAL_CARD,
                       /*has_more_button=*/false,
                       /*show_if_empty=*/false);
 }
 
 void OfflinePageSuggestionsProvider::DismissSuggestion(
-    const std::string& suggestion_id) {
-  Category category = GetCategoryFromUniqueID(suggestion_id);
-  std::string offline_page_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
-  std::set<std::string> dismissed_ids = ReadDismissedIDsFromPrefs(category);
-  dismissed_ids.insert(offline_page_id);
-  StoreDismissedIDsToPrefs(category, dismissed_ids);
+    const ContentSuggestion::ID& suggestion_id) {
+  std::set<std::string> dismissed_ids =
+      ReadDismissedIDsFromPrefs(suggestion_id.category());
+  dismissed_ids.insert(suggestion_id.within_category_id());
+  StoreDismissedIDsToPrefs(suggestion_id.category(), dismissed_ids);
 }
 
 void OfflinePageSuggestionsProvider::FetchSuggestionImage(
-    const std::string& suggestion_id,
+    const ContentSuggestion::ID& suggestion_id,
     const ImageFetchedCallback& callback) {
   // TODO(pke): Fetch proper thumbnail from OfflinePageModel once it's available
   // there.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, gfx::Image()));
 }
 
 void OfflinePageSuggestionsProvider::ClearHistory(
     base::Time begin,
     base::Time end,
@@ skipping 149 matching lines @@
     NOTREACHED() << "Unknown category " << category.id();
   }
 }
 
 ContentSuggestion OfflinePageSuggestionsProvider::ConvertOfflinePage(
     Category category,
     const OfflinePageItem& offline_page) const {
   // TODO(pke): Make sure the URL is actually opened as an offline URL.
   // Currently, the browser opens the offline URL and then immediately
   // redirects to the online URL if the device is online.
-  ContentSuggestion suggestion(
-      MakeUniqueID(category, base::IntToString(offline_page.offline_id)),
-      offline_page.GetOfflineURL());
+  ContentSuggestion suggestion(category,
+                               base::IntToString(offline_page.offline_id),
+                               offline_page.GetOfflineURL());
 
   if (offline_page.title.empty()) {
     // TODO(pke): Remove this fallback once the OfflinePageModel provides titles
     // for all (relevant) OfflinePageItems.
     suggestion.set_title(base::UTF8ToUTF16(offline_page.url.spec()));
   } else {
     suggestion.set_title(offline_page.title);
   }
   suggestion.set_publish_date(offline_page.creation_time);
   suggestion.set_publisher_name(base::UTF8ToUTF16(offline_page.url.host()));
@@ skipping 11 matching lines @@
     suggestions.push_back(ConvertOfflinePage(category, *offline_page_item));
     if (suggestions.size() == kMaxSuggestionsCount)
       break;
   }
   return suggestions;
 }
 
 void OfflinePageSuggestionsProvider::InvalidateSuggestion(Category category,
                                                           int64_t offline_id) {
   std::string offline_page_id = base::IntToString(offline_id);
-  observer()->OnSuggestionInvalidated(this, category,
-                                      MakeUniqueID(category, offline_page_id));
+  observer()->OnSuggestionInvalidated(
+      this, ContentSuggestion::ID(category, offline_page_id));
 
   std::set<std::string> dismissed_ids = ReadDismissedIDsFromPrefs(category);
   auto it =
       std::find(dismissed_ids.begin(), dismissed_ids.end(), offline_page_id);
   if (it != dismissed_ids.end()) {
     dismissed_ids.erase(it);
     StoreDismissedIDsToPrefs(category, dismissed_ids);
   }
 }
 
@@ skipping 14 matching lines @@
 }
 
 void OfflinePageSuggestionsProvider::StoreDismissedIDsToPrefs(
     Category category,
     const std::set<std::string>& dismissed_ids) {
   prefs::StoreDismissedIDsToPrefs(pref_service_, GetDismissedPref(category),
                                   dismissed_ids);
 }
 
 }  // namespace ntp_snippets