Make bookmark suggestions dismissable

components/ntp_snippets/bookmarks/bookmark_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/bookmarks/bookmark_suggestions_provider.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 71 matching lines @@
 }
 
 CategoryStatus BookmarkSuggestionsProvider::GetCategoryStatus(
     Category category) {
   DCHECK_EQ(category, provided_category_);
   return category_status_;
 }
 
 void BookmarkSuggestionsProvider::DismissSuggestion(
     const std::string& suggestion_id) {
-  // TODO(jkrcal): Implement blacklisting bookmarks until they are next visited.
-  // Then also implement ClearDismissedSuggestionsForDebugging.
+  DCHECK(bookmark_model_->loaded());
+  GURL url(GetWithinCategoryIDFromUniqueID(suggestion_id));
+  MarkBookmarksDismissed(bookmark_model_, url);
 }
 
 void BookmarkSuggestionsProvider::FetchSuggestionImage(
     const std::string& suggestion_id,
     const ImageFetchedCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, suggestion_id, gfx::Image()));
 }
 
 void BookmarkSuggestionsProvider::ClearCachedSuggestionsForDebugging(
     Category category) {
   DCHECK_EQ(category, provided_category_);
   // Ignored.
 }
 
 std::vector<ContentSuggestion>
 BookmarkSuggestionsProvider::GetDismissedSuggestionsForDebugging(
     Category category) {
   DCHECK_EQ(category, provided_category_);
-  // TODO(pke): Implement when discarded suggestions are supported.
-  return std::vector<ContentSuggestion>();
+  std::vector<const BookmarkNode*> bookmarks =
+      GetDismissedBookmarksForDebugging(bookmark_model_);
+
+  std::vector<ContentSuggestion> suggestions;
+  for (const BookmarkNode* bookmark : bookmarks)
+    suggestions.emplace_back(ConvertBookmark(bookmark));
+  return suggestions;
 }
 
 void BookmarkSuggestionsProvider::ClearDismissedSuggestionsForDebugging(
     Category category) {
   DCHECK_EQ(category, provided_category_);
-  // TODO(pke): Implement when discarded suggestions are supported.
+  if (!bookmark_model_->loaded())
+    return;
+  MarkAllBookmarksUndismissed(bookmark_model_);
 }
 
 void BookmarkSuggestionsProvider::BookmarkModelLoaded(
     bookmarks::BookmarkModel* model,
     bool ids_reassigned) {
   DCHECK_EQ(bookmark_model_, model);
   if (fetch_requested_) {
     fetch_requested_ = false;
     FetchBookmarksInternal();
   }
@@ skipping 12 matching lines @@
   base::Time time = GetLastVisitDateForBookmark(node);
   if (time == node_to_change_last_visit_date_ ||
       time < end_of_list_last_visit_date_)
     return;
 
   // Last visit date of a node has changed (and is relevant for the list), we
   // should update the suggestions.
   FetchBookmarks();
 }
 
+ContentSuggestion BookmarkSuggestionsProvider::ConvertBookmark(
+    const BookmarkNode* bookmark) {
+  ContentSuggestion suggestion(
+      MakeUniqueID(provided_category_, bookmark->url().spec()),
+      bookmark->url());
+
+  suggestion.set_title(bookmark->GetTitle());
+  suggestion.set_snippet_text(base::string16());
+  suggestion.set_publish_date(GetLastVisitDateForBookmark(bookmark));
+  suggestion.set_publisher_name(base::UTF8ToUTF16(bookmark->url().host()));
+  return suggestion;
+}
+
 void BookmarkSuggestionsProvider::FetchBookmarksInternal() {
   DCHECK(bookmark_model_->loaded());
 
   NotifyStatusChanged(CategoryStatus::AVAILABLE);
 
   base::Time threshold_time = GetThresholdTime();
   std::vector<const BookmarkNode*> bookmarks = GetRecentlyVisitedBookmarks(
       bookmark_model_, GetMaxCount(), threshold_time);
 
   std::vector<ContentSuggestion> suggestions;
-  for (const BookmarkNode* bookmark : bookmarks) {
-    ContentSuggestion suggestion(
-        MakeUniqueID(provided_category_, bookmark->url().spec()),
-        bookmark->url());
-
-    suggestion.set_title(bookmark->GetTitle());
-    suggestion.set_snippet_text(base::string16());
-    suggestion.set_publish_date(GetLastVisitDateForBookmark(bookmark));
-    suggestion.set_publisher_name(base::UTF8ToUTF16(bookmark->url().host()));
-    suggestions.emplace_back(std::move(suggestion));
-  }
+  for (const BookmarkNode* bookmark : bookmarks)
+    suggestions.emplace_back(ConvertBookmark(bookmark));
 
   if (suggestions.empty())
     end_of_list_last_visit_date_ = threshold_time;
   else
     end_of_list_last_visit_date_ = suggestions.back().publish_date();
 
   observer()->OnNewSuggestions(this, provided_category_,
                                std::move(suggestions));
 }
 
 void BookmarkSuggestionsProvider::FetchBookmarks() {
   if (bookmark_model_->loaded())
     FetchBookmarksInternal();
   else
     fetch_requested_ = true;
 }
 
 void BookmarkSuggestionsProvider::NotifyStatusChanged(
     CategoryStatus new_status) {
   if (category_status_ == new_status)
     return;
   category_status_ = new_status;
   observer()->OnCategoryStatusChanged(this, provided_category_, new_status);
 }
 
 }  // namespace ntp_snippets