Prefetching: Introduce store commands abstractions to be used by tasks.

components/offline_pages/core/prefetch/suggested_articles_observer.cc

 // Copyright 2017 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/offline_pages/core/prefetch/suggested_articles_observer.h"
 
 #include <unordered_set>
 
 #include "base/memory/ptr_util.h"
 #include "components/ntp_snippets/category.h"
@@ skipping 10 matching lines @@
 namespace offline_pages {
 
 namespace {
 
 const ntp_snippets::Category& ArticlesCategory() {
   static ntp_snippets::Category articles =
       Category::FromKnownCategory(ntp_snippets::KnownCategories::ARTICLES);
   return articles;
 }
 
-ClientId CreateClientIDFromSuggestionId(const ContentSuggestion::ID& id) {
-  return ClientId(kSuggestedArticlesNamespace, id.id_within_category());
-}
-
 }  // namespace
 
 SuggestedArticlesObserver::SuggestedArticlesObserver(
     PrefetchDispatcher* dispatcher)
     : prefetch_dispatcher_(dispatcher) {
   DCHECK(prefetch_dispatcher_);
 }
 
 SuggestedArticlesObserver::~SuggestedArticlesObserver() {
   if (content_suggestions_service_)
@@ skipping 19 matching lines @@
   const std::vector<ContentSuggestion>& suggestions =
       test_articles_ ? *test_articles_
                      : content_suggestions_service_->GetSuggestionsForCategory(
                            ArticlesCategory());
   if (suggestions.empty())
     return;
 
   std::vector<PrefetchURL> prefetch_urls;
   for (const ContentSuggestion& suggestion : suggestions) {
     prefetch_urls.push_back(
-        {CreateClientIDFromSuggestionId(suggestion.id()), suggestion.url()});
+        {suggestion.id().id_within_category(), suggestion.url()});
   }
 
-  prefetch_dispatcher_->AddCandidatePrefetchURLs(prefetch_urls);
+  prefetch_dispatcher_->AddCandidatePrefetchURLs(kSuggestedArticlesNamespace,
+                                                 prefetch_urls);
 }
 
 void SuggestedArticlesObserver::OnCategoryStatusChanged(
     Category category,
     ntp_snippets::CategoryStatus new_status) {
   if (category != ArticlesCategory() || category_status_ == new_status)
     return;
 
   category_status_ = new_status;
 
   if (category_status_ ==
           ntp_snippets::CategoryStatus::CATEGORY_EXPLICITLY_DISABLED ||
       category_status_ ==
           ntp_snippets::CategoryStatus::ALL_SUGGESTIONS_EXPLICITLY_DISABLED) {
     prefetch_dispatcher_->RemoveAllUnprocessedPrefetchURLs(
         kSuggestedArticlesNamespace);
   }
 }
 
 void SuggestedArticlesObserver::OnSuggestionInvalidated(
     const ContentSuggestion::ID& suggestion_id) {
-  prefetch_dispatcher_->RemovePrefetchURLsByClientId(
-      CreateClientIDFromSuggestionId(suggestion_id));
+  prefetch_dispatcher_->RemovePrefetchURLsByClientId(ClientId(
+      kSuggestedArticlesNamespace, suggestion_id.id_within_category()));
 }
 
 void SuggestedArticlesObserver::OnFullRefreshRequired() {
   prefetch_dispatcher_->RemoveAllUnprocessedPrefetchURLs(
       kSuggestedArticlesNamespace);
   OnNewSuggestions(ArticlesCategory());
 }
 
 void SuggestedArticlesObserver::ContentSuggestionsServiceShutdown() {
   // No need to do anything here, we will just stop getting events.
 }
 
 std::vector<ntp_snippets::ContentSuggestion>*
 SuggestedArticlesObserver::GetTestingArticles() {
   if (!test_articles_) {
     test_articles_ =
         base::MakeUnique<std::vector<ntp_snippets::ContentSuggestion>>();
   }
   return test_articles_.get();
 }
 
 }  // namespace offline_pages