[NTP Snippets] Introduce ContentSuggestion::ID

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>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
+#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/image_fetcher/image_decoder.h"
 #include "components/image_fetcher/image_fetcher.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
@@ skipping 286 matching lines @@
 
 CategoryInfo NTPSnippetsService::GetCategoryInfo(Category category) {
   DCHECK(categories_.find(category) != categories_.end());
   const CategoryContent& content = categories_[category];
   return CategoryInfo(content.localized_title,
                       ContentSuggestionsCardLayout::FULL_CARD,
                       /* has_more_button */ false,
                       /* show_if_empty */ true);
 }
 
-void NTPSnippetsService::DismissSuggestion(const std::string& suggestion_id) {
+void NTPSnippetsService::DismissSuggestion(
+    const ContentSuggestion::ID& suggestion_id) {
   if (!ready())
     return;
 
-  Category category = GetCategoryFromUniqueID(suggestion_id);
-  std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
+  DCHECK(base::ContainsKey(categories_, suggestion_id.category()));
 
-  DCHECK(categories_.find(category) != categories_.end());
-
-  CategoryContent* content = &categories_[category];
-  auto it =
-      std::find_if(content->snippets.begin(), content->snippets.end(),
-                   [&snippet_id](const std::unique_ptr<NTPSnippet>& snippet) {
-                     return snippet->id() == snippet_id;
-                   });
+  CategoryContent* content = &categories_[suggestion_id.category()];
+  auto it = std::find_if(
+      content->snippets.begin(), content->snippets.end(),
+      [&suggestion_id](const std::unique_ptr<NTPSnippet>& snippet) {
+        return snippet->id() == suggestion_id.id_within_category();
+      });
   if (it == content->snippets.end())
     return;
 
   (*it)->set_dismissed(true);
 
   database_->SaveSnippet(**it);
-  database_->DeleteImage(snippet_id);
+  database_->DeleteImage(suggestion_id.id_within_category());
 
   content->dismissed.push_back(std::move(*it));
   content->snippets.erase(it);
 }
 
 void NTPSnippetsService::FetchSuggestionImage(
-    const std::string& suggestion_id,
+    const ContentSuggestion::ID& suggestion_id,
     const ImageFetchedCallback& callback) {
-  std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
   database_->LoadImage(
-      snippet_id,
+      suggestion_id.id_within_category(),
       base::Bind(&NTPSnippetsService::OnSnippetImageFetchedFromDatabase,
                  base::Unretained(this), callback, suggestion_id));
 }
 
 void NTPSnippetsService::ClearHistory(
     base::Time begin,
     base::Time end,
     const base::Callback<bool(const GURL& url)>& filter) {
   // Both time range and the filter are ignored and all suggestions are removed,
   // because it is not known which history entries were used for the suggestions
@@ skipping 26 matching lines @@
 void NTPSnippetsService::GetDismissedSuggestionsForDebugging(
     Category category,
     const DismissedSuggestionsCallback& callback) {
   DCHECK(categories_.find(category) != categories_.end());
 
   std::vector<ContentSuggestion> result;
   const CategoryContent& content = categories_[category];
   for (const std::unique_ptr<NTPSnippet>& snippet : content.dismissed) {
     if (!snippet->is_complete())
       continue;
-    ContentSuggestion suggestion(MakeUniqueID(category, snippet->id()),
+    ContentSuggestion suggestion(category, snippet->id(),
                                  snippet->best_source().url);
     suggestion.set_amp_url(snippet->best_source().amp_url);
     suggestion.set_title(base::UTF8ToUTF16(snippet->title()));
     suggestion.set_snippet_text(base::UTF8ToUTF16(snippet->snippet()));
     suggestion.set_publish_date(snippet->publish_date());
     suggestion.set_publisher_name(
         base::UTF8ToUTF16(snippet->best_source().publisher_name));
     suggestion.set_score(snippet->score());
     result.emplace_back(std::move(suggestion));
   }
@@ skipping 30 matching lines @@
 
 // static
 int NTPSnippetsService::GetMaxSnippetCountForTesting() {
   return kMaxSnippetCount;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Private methods
 
 GURL NTPSnippetsService::FindSnippetImageUrl(
-    Category category,
-    const std::string& snippet_id) const {
-  DCHECK(categories_.find(category) != categories_.end());
+    const ContentSuggestion::ID& suggestion_id) const {
+  DCHECK(categories_.find(suggestion_id.category()) != categories_.end());
 
-  const CategoryContent& content = categories_.at(category);
-  // Search for the snippet in current and archived snippets.
-  auto it =
-      std::find_if(content.snippets.begin(), content.snippets.end(),
-                   [&snippet_id](const std::unique_ptr<NTPSnippet>& snippet) {
-                     return snippet->id() == snippet_id;
-                   });
-  if (it != content.snippets.end())
-    return (*it)->salient_image_url();
-
-  it = std::find_if(content.archived.begin(), content.archived.end(),
-                    [&snippet_id](const std::unique_ptr<NTPSnippet>& snippet) {
-                      return snippet->id() == snippet_id;
-                    });
-  if (it != content.archived.end())
-    return (*it)->salient_image_url();
-
-  return GURL();
+  const CategoryContent& content = categories_.at(suggestion_id.category());
+  const NTPSnippet* snippet =
+      content.FindSnippet(suggestion_id.id_within_category());
+  if (!snippet)
+    return GURL();
+  return snippet->salient_image_url();
 }
 
 // image_fetcher::ImageFetcherDelegate implementation.
-void NTPSnippetsService::OnImageDataFetched(const std::string& suggestion_id,
-                                            const std::string& image_data) {
+void NTPSnippetsService::OnImageDataFetched(
+    const std::string& id_within_category,
+    const std::string& image_data) {
   if (image_data.empty())
     return;
 
-  Category category = GetCategoryFromUniqueID(suggestion_id);
-  std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
-
-  if (categories_.find(category) == categories_.end())
-    return;
-
   // Only save the image if the corresponding snippet still exists.
-  if (FindSnippetImageUrl(category, snippet_id).is_empty())
+  bool found = false;
+  for (const std::pair<const Category, CategoryContent>& entry : categories_) {
+    if (entry.second.FindSnippet(id_within_category)) {
+      found = true;
+      break;
+    }
+  }
+  if (!found)
     return;
 
   // Only cache the data in the DB, the actual serving is done in the callback
   // provided to |image_fetcher_| (OnSnippetImageDecodedFromNetwork()).
-  database_->SaveImage(snippet_id, image_data);
+  database_->SaveImage(id_within_category, image_data);
 }
 
 void NTPSnippetsService::OnDatabaseLoaded(NTPSnippet::PtrVector snippets) {
   if (state_ == State::ERROR_OCCURRED)
     return;
   DCHECK(state_ == State::NOT_INITED);
   DCHECK_EQ(1u, categories_.size());  // Only articles category, so far.
   DCHECK(categories_.find(articles_category_) != categories_.end());
 
   // TODO(sfiera): support non-article categories in database.
@@ skipping 305 matching lines @@
     }
   }
 
   for (Category category : categories_to_erase) {
     categories_.erase(category);
   }
 }
 
 void NTPSnippetsService::OnSnippetImageFetchedFromDatabase(
     const ImageFetchedCallback& callback,
-    const std::string& suggestion_id,
+    const ContentSuggestion::ID& suggestion_id,
     std::string data) {
   // |image_decoder_| is null in tests.
   if (image_decoder_ && !data.empty()) {
     image_decoder_->DecodeImage(
         data, base::Bind(&NTPSnippetsService::OnSnippetImageDecodedFromDatabase,
                          base::Unretained(this), callback, suggestion_id));
     return;
   }
 
   // Fetching from the DB failed; start a network fetch.
   FetchSnippetImageFromNetwork(suggestion_id, callback);
 }
 
 void NTPSnippetsService::OnSnippetImageDecodedFromDatabase(
     const ImageFetchedCallback& callback,
-    const std::string& suggestion_id,
+    const ContentSuggestion::ID& suggestion_id,
     const gfx::Image& image) {
   if (!image.IsEmpty()) {
     callback.Run(image);
     return;
   }
 
   // If decoding the image failed, delete the DB entry.
-  std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
-  database_->DeleteImage(snippet_id);
+  database_->DeleteImage(suggestion_id.id_within_category());
 
   FetchSnippetImageFromNetwork(suggestion_id, callback);
 }
 
 void NTPSnippetsService::FetchSnippetImageFromNetwork(
-    const std::string& suggestion_id,
+    const ContentSuggestion::ID& suggestion_id,
     const ImageFetchedCallback& callback) {
-  Category category = GetCategoryFromUniqueID(suggestion_id);
-  std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
-
-  if (categories_.find(category) == categories_.end()) {
-    OnSnippetImageDecodedFromNetwork(callback, suggestion_id, gfx::Image());
+  if (categories_.find(suggestion_id.category()) == categories_.end()) {
+    OnSnippetImageDecodedFromNetwork(
+        callback, suggestion_id.id_within_category(), gfx::Image());
     return;
   }
 
-  GURL image_url = FindSnippetImageUrl(category, snippet_id);
+  GURL image_url = FindSnippetImageUrl(suggestion_id);
 
   if (image_url.is_empty() ||
       !thumbnail_requests_throttler_.DemandQuotaForRequest(
           /*interactive_request=*/true)) {
     // Return an empty image. Directly, this is never synchronous with the
     // original FetchSuggestionImage() call - an asynchronous database query has
     // happened in the meantime.
-    OnSnippetImageDecodedFromNetwork(callback, suggestion_id, gfx::Image());
+    OnSnippetImageDecodedFromNetwork(
+        callback, suggestion_id.id_within_category(), gfx::Image());
     return;
   }
 
   image_fetcher_->StartOrQueueNetworkRequest(
-      suggestion_id, image_url,
+      suggestion_id.id_within_category(), image_url,
       base::Bind(&NTPSnippetsService::OnSnippetImageDecodedFromNetwork,
                  base::Unretained(this), callback));
 }
 
 void NTPSnippetsService::OnSnippetImageDecodedFromNetwork(
     const ImageFetchedCallback& callback,
-    const std::string& suggestion_id,
+    const std::string& id_within_category,
     const gfx::Image& image) {
   callback.Run(image);
 }
 
 void NTPSnippetsService::EnterStateReady() {
   if (nuke_when_initialized_) {
     NukeAllSnippets();
     nuke_when_initialized_ = false;
   }
 
@@ skipping 125 matching lines @@
     const CategoryContent& content = item.second;
 
     std::vector<ContentSuggestion> result;
     for (const std::unique_ptr<NTPSnippet>& snippet : content.snippets) {
       // TODO(sfiera): if a snippet is not going to be displayed, move it
       // directly to content.dismissed on fetch. Otherwise, we might prune
       // other snippets to get down to kMaxSnippetCount, only to hide one of the
       // incomplete ones we kept.
       if (!snippet->is_complete())
         continue;
-      ContentSuggestion suggestion(MakeUniqueID(category, snippet->id()),
+      ContentSuggestion suggestion(category, snippet->id(),
                                    snippet->best_source().url);
       suggestion.set_amp_url(snippet->best_source().amp_url);
       suggestion.set_title(base::UTF8ToUTF16(snippet->title()));
       suggestion.set_snippet_text(base::UTF8ToUTF16(snippet->snippet()));
       suggestion.set_publish_date(snippet->publish_date());
       suggestion.set_publisher_name(
           base::UTF8ToUTF16(snippet->best_source().publisher_name));
       suggestion.set_score(snippet->score());
       result.emplace_back(std::move(suggestion));
     }
@@ skipping 17 matching lines @@
   content.status = status;
   observer()->OnCategoryStatusChanged(this, category, content.status);
 }
 
 void NTPSnippetsService::UpdateAllCategoryStatus(CategoryStatus status) {
   for (const auto& category : categories_) {
     UpdateCategoryStatus(category.first, status);
   }
 }
 
+const NTPSnippet* NTPSnippetsService::CategoryContent::FindSnippet(
+    const std::string& id_within_category) const {
+  // Search for the snippet in current and archived snippets.
+  auto it = std::find_if(
+      snippets.begin(), snippets.end(),
+      [&id_within_category](const std::unique_ptr<NTPSnippet>& snippet) {
+        return snippet->id() == id_within_category;
+      });
+  if (it != snippets.end())
+    return it->get();
+
+  it = std::find_if(
+      archived.begin(), archived.end(),
+      [&id_within_category](const std::unique_ptr<NTPSnippet>& snippet) {
+        return snippet->id() == id_within_category;
+      });
+  if (it != archived.end())
+    return it->get();
+
+  return nullptr;
+}
+
 NTPSnippetsService::CategoryContent::CategoryContent() = default;
 NTPSnippetsService::CategoryContent::CategoryContent(CategoryContent&&) =
     default;
 NTPSnippetsService::CategoryContent::~CategoryContent() = default;
 NTPSnippetsService::CategoryContent& NTPSnippetsService::CategoryContent::
 operator=(CategoryContent&&) = default;
 
 }  // namespace ntp_snippets