Change NTPSnippetsBridge to read from ContentSuggestionsService

components/ntp_snippets/ntp_snippets_service.cc

 // Copyright 2015 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/ntp_snippets_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 259 matching lines @@
         GetFetchingIntervalWifiCharging(), GetFetchingIntervalWifi(now),
         GetFetchingIntervalFallback(), GetRescheduleTime(now));
   } else {
     scheduler_->Unschedule();
   }
 }
 
 void NTPSnippetsService::FetchSuggestionImage(
     const std::string& suggestion_id,
     const ImageFetchedCallback& callback) {
+  std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
   database_->LoadImage(
-      suggestion_id,

[Marc Treib, 2016/07/19 09:30:25]

Wait, so this only worked because suggestion_id was in fact a within-category-id
so far?

[Philipp Keck, 2016/07/19 12:21:50]

Yes. This method implements two different interfaces: The FetchImage method for
the old NTPSnippetsService and the
ContentSuggestionsProvider::FetchSuggestImage. Same for DiscardSuggestion. For a
cleaner solution, the implementation of this method should probably have been
different in a previous CL.

This previously only worked because it was never called in the context of the
ContentSuggestions interface. And in the future it will only work if nobody
calls it with an ID they retrieved from snippets(). Maybe should rename
snippets() to snippetsForDebugging() now, because only the snippets-internals
page should use it.

+      snippet_id,
       base::Bind(&NTPSnippetsService::OnSnippetImageFetchedFromDatabase,
-                 base::Unretained(this), suggestion_id, callback));
+                 base::Unretained(this), snippet_id, callback));
 }
 
 void NTPSnippetsService::ClearCachedSuggestionsForDebugging() {
   if (!initialized())
     return;
 
   if (snippets_.empty())
     return;
 
   database_->DeleteSnippets(snippets_);
   snippets_.clear();
 
   NotifyNewSuggestions();
 }
 
 std::set<std::string> NTPSnippetsService::GetSuggestionsHosts() const {
   // |suggestions_service_| can be null in tests.
   if (!suggestions_service_)
     return std::set<std::string>();
 
   // TODO(treib): This should just call GetSnippetHostsFromPrefs.
   return GetSuggestionsHostsImpl(
       suggestions_service_->GetSuggestionsDataFromCache());
 }
 
 void NTPSnippetsService::DiscardSuggestion(const std::string& suggestion_id) {
   if (!ready())
     return;
 
-  auto it = std::find_if(
-      snippets_.begin(), snippets_.end(),
-      [&suggestion_id](const std::unique_ptr<NTPSnippet>& snippet) {
-        return snippet->id() == suggestion_id;
-      });
+  std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
+
+  auto it =
+      std::find_if(snippets_.begin(), snippets_.end(),
+                   [&snippet_id](const std::unique_ptr<NTPSnippet>& snippet) {
+                     return snippet->id() == snippet_id;
+                   });
   if (it == snippets_.end())
     return;
 
   (*it)->set_discarded(true);
 
   database_->SaveSnippet(**it);
   database_->DeleteImage((*it)->id());
 
   discarded_snippets_.push_back(std::move(*it));
   snippets_.erase(it);
-
-  NotifyNewSuggestions();
 }
 
 void NTPSnippetsService::ClearDiscardedSuggestionsForDebugging() {
   if (!initialized())
     return;
 
   if (discarded_snippets_.empty())
     return;
 
   database_->DeleteSnippets(discarded_snippets_);
@@ skipping 272 matching lines @@
 
   // Fetching from the DB failed; start a network fetch.
   FetchSnippetImageFromNetwork(snippet_id, callback);
 }
 
 void NTPSnippetsService::OnSnippetImageDecoded(
     const std::string& snippet_id,
     const ImageFetchedCallback& callback,
     const gfx::Image& image) {
   if (!image.IsEmpty()) {
-    callback.Run(snippet_id, image);
+    callback.Run(MakeUniqueID(ContentSuggestionsCategory::ARTICLES, snippet_id),
+                 image);
     return;
   }
 
   // If decoding the image failed, delete the DB entry.
   database_->DeleteImage(snippet_id);
 
   FetchSnippetImageFromNetwork(snippet_id, callback);
 }
 
 void NTPSnippetsService::FetchSnippetImageFromNetwork(
     const std::string& snippet_id,
     const ImageFetchedCallback& callback) {
   auto it =
       std::find_if(snippets_.begin(), snippets_.end(),
                    [&snippet_id](const std::unique_ptr<NTPSnippet>& snippet) {
                      return snippet->id() == snippet_id;
                    });
   if (it == snippets_.end()) {
-    callback.Run(snippet_id, gfx::Image());
+    callback.Run(MakeUniqueID(ContentSuggestionsCategory::ARTICLES, snippet_id),
+                 gfx::Image());
     return;
   }
 
   const NTPSnippet& snippet = *it->get();
   image_fetcher_->StartOrQueueNetworkRequest(
       snippet.id(), snippet.salient_image_url(), callback);
 }
 
 void NTPSnippetsService::EnterStateEnabled(bool fetch_snippets) {
   if (fetch_snippets)
@@ skipping 163 matching lines @@
 }
 
 void NTPSnippetsService::NotifyCategoryStatusChanged() {
   if (observer_) {
     observer_->OnCategoryStatusChanged(ContentSuggestionsCategory::ARTICLES,
                                        category_status_);
   }
 }
 
 }  // namespace ntp_snippets