ReadingListProvider handles dismissal

components/ntp_snippets/reading_list/reading_list_suggestions_provider.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/ntp_snippets/reading_list/reading_list_suggestions_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 52 matching lines @@
                           IDS_NTP_READING_LIST_SUGGESTIONS_SECTION_HEADER),
                       ContentSuggestionsCardLayout::FULL_CARD,
                       ContentSuggestionsAdditionalAction::VIEW_ALL,
                       /*show_if_empty=*/false,
                       l10n_util::GetStringUTF16(
                           IDS_NTP_READING_LIST_SUGGESTIONS_SECTION_EMPTY));
 }
 
 void ReadingListSuggestionsProvider::DismissSuggestion(
     const ContentSuggestion::ID& suggestion_id) {
-  // TODO(crbug.com/702241): Implement this method.
+  if (!reading_list_model_) {
+    return;
+  }
+
+  DCHECK(reading_list_model_->loaded());
+  GURL url(suggestion_id.id_within_category());
+  SetDismissedState(url, true);
 }
 
 void ReadingListSuggestionsProvider::FetchSuggestionImage(
     const ContentSuggestion::ID& suggestion_id,
     const ImageFetchedCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, gfx::Image()));
 }
 
 void ReadingListSuggestionsProvider::Fetch(
     const Category& category,
     const std::set<std::string>& known_suggestion_ids,
     const FetchDoneCallback& callback) {
   LOG(DFATAL) << "ReadingListSuggestionsProvider has no |Fetch| functionality!";
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  Status(StatusCode::PERMANENT_ERROR,
                         "ReadingListSuggestionsProvider has no |Fetch| "
                         "functionality!"),
                  base::Passed(std::vector<ContentSuggestion>())));
 }
 
 void ReadingListSuggestionsProvider::ClearHistory(
     base::Time begin,
     base::Time end,
     const base::Callback<bool(const GURL& url)>& filter) {
-  // TODO(crbug.com/702241): Implement this method.
+  // Ignored, Reading List does not depend on history.
 }
 
 void ReadingListSuggestionsProvider::ClearCachedSuggestions(Category category) {
   DCHECK_EQ(category, provided_category_);
   // Ignored.
 }
 
 void ReadingListSuggestionsProvider::GetDismissedSuggestionsForDebugging(
     Category category,
     const DismissedSuggestionsCallback& callback) {
-  // TODO(crbug.com/702241): Implement this method.
+  if (!reading_list_model_ || reading_list_model_->IsPerformingBatchUpdates()) {
+    callback.Run(std::vector<ContentSuggestion>());
+    return;
+  }
+
+  DCHECK(reading_list_model_->loaded());
+  std::vector<const ReadingListEntry*> entries;
+  for (const GURL& url : reading_list_model_->Keys()) {
+    const ReadingListEntry* entry = reading_list_model_->GetEntryByURL(url);
+    if (entry->ContentSuggestionsExtra()->dismissed) {
+      entries.emplace_back(entry);
+    }
+  }
+
+  std::sort(entries.begin(), entries.end(), CompareEntries);
+
+  std::vector<ContentSuggestion> suggestions;
+  for (const ReadingListEntry* entry : entries) {
+    suggestions.emplace_back(ConvertEntry(entry));
+  }
+
+  callback.Run(std::move(suggestions));
 }
+
 void ReadingListSuggestionsProvider::ClearDismissedSuggestionsForDebugging(
     Category category) {
-  // TODO(crbug.com/702241): Implement this method.
+  for (const auto& url : reading_list_model_->Keys()) {
+    SetDismissedState(url, false);
+  }
 }
 
 void ReadingListSuggestionsProvider::ReadingListModelLoaded(
     const ReadingListModel* model) {
   DCHECK(model == reading_list_model_);
   FetchReadingListInternal();
 }
 
 void ReadingListSuggestionsProvider::ReadingListModelBeingDeleted(
     const ReadingListModel* model) {
@@ skipping 18 matching lines @@
 
 void ReadingListSuggestionsProvider::FetchReadingListInternal() {
   if (!reading_list_model_ || reading_list_model_->IsPerformingBatchUpdates()) {
     return;
   }
 
   DCHECK(reading_list_model_->loaded());
   std::vector<const ReadingListEntry*> entries;
   for (const GURL& url : reading_list_model_->Keys()) {
     const ReadingListEntry* entry = reading_list_model_->GetEntryByURL(url);
-    if (!entry->IsRead()) {
+    if (!entry->IsRead() && !entry->ContentSuggestionsExtra()->dismissed) {
       entries.emplace_back(entry);
     }
   }
 
   if (entries.size() > kMaxEntries) {
     // Get the |kMaxEntries| most recent entries.
     std::partial_sort(entries.begin(), entries.begin() + kMaxEntries,
                       entries.end(), CompareEntries);
     entries.resize(kMaxEntries);
   } else {
@@ skipping 35 matching lines @@
 
 void ReadingListSuggestionsProvider::NotifyStatusChanged(
     CategoryStatus new_status) {
   if (category_status_ == new_status) {
     return;
   }
   category_status_ = new_status;
   observer()->OnCategoryStatusChanged(this, provided_category_, new_status);
 }
 
+void ReadingListSuggestionsProvider::SetDismissedState(const GURL& url,
+                                                       bool dismissed) {
+  reading_list::ContentSuggestionsExtra extra;
+  extra.dismissed = dismissed;
+  reading_list_model_->SetContentSuggestionsExtra(url, extra);
+}
+
 }  // namespace ntp_snippets