Make GetDismissedSuggestionsForDebugging asynchronous

components/ntp_snippets/offline_pages/offline_page_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/offline_pages/offline_page_suggestions_provider.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/guid.h"
@@ skipping 20 matching lines @@
 
 const int kMaxSuggestionsCount = 5;
 
 struct OrderByMostRecentlyVisited {
   bool operator()(const OfflinePageItem* left,
                   const OfflinePageItem* right) const {
     return left->last_access_time > right->last_access_time;
   }
 };
 
+bool IsRecentTab(const offline_pages::ClientId& client_id) {
+  return client_id.name_space == offline_pages::kLastNNamespace;
+}
+
+bool IsDownload(const offline_pages::ClientId& client_id) {
+  // TODO(pke): Use kDownloadNamespace once the OfflinePageModel uses that.
+  // The current logic is taken from DownloadUIAdapter::IsVisibleInUI.
+  return client_id.name_space == offline_pages::kAsyncNamespace &&
+         base::IsValidGUID(client_id.id);
+}
+
 }  // namespace
 
 OfflinePageSuggestionsProvider::OfflinePageSuggestionsProvider(
     bool recent_tabs_enabled,
     bool downloads_enabled,
     bool download_manager_ui_enabled,
     ContentSuggestionsProvider::Observer* observer,
     CategoryFactory* category_factory,
     OfflinePageModel* offline_page_model,
     PrefService* pref_service)
@@ skipping 84 matching lines @@
   // there.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, suggestion_id, gfx::Image()));
 }
 
 void OfflinePageSuggestionsProvider::ClearCachedSuggestionsForDebugging(
     Category category) {
   // Ignored.
 }
 
-std::vector<ContentSuggestion>
-OfflinePageSuggestionsProvider::GetDismissedSuggestionsForDebugging(
-    Category category) {
-  // TODO(pke): Make GetDismissedSuggestionsForDebugging asynchronous so this
-  // can return proper values.
-  std::set<std::string> dismissed_ids = ReadDismissedIDsFromPrefs(category);
-  std::vector<ContentSuggestion> suggestions;
-  for (const std::string& dismissed_id : dismissed_ids) {
-    ContentSuggestion suggestion(
-        MakeUniqueID(category, dismissed_id),
-        GURL("http://dismissed-offline-page-" + dismissed_id));
-    suggestion.set_title(base::UTF8ToUTF16("Title not available"));
-    suggestions.push_back(std::move(suggestion));
-  }
-  return suggestions;
+void OfflinePageSuggestionsProvider::GetDismissedSuggestionsForDebugging(
+    Category category,
+    const DismissedSuggestionsCallback& callback) {
+  offline_page_model_->GetAllPages(
+      base::Bind(&OfflinePageSuggestionsProvider::
+                     OnOfflinePagesLoadedForDismissedDebugging,
+                 base::Unretained(this), category, callback));
 }
 
 void OfflinePageSuggestionsProvider::ClearDismissedSuggestionsForDebugging(
     Category category) {
   StoreDismissedIDsToPrefs(category, std::set<std::string>());
   FetchOfflinePages();
 }
 
 void OfflinePageSuggestionsProvider::OfflinePageModelLoaded(
     OfflinePageModel* model) {
   DCHECK_EQ(offline_page_model_, model);
 }
 
 void OfflinePageSuggestionsProvider::OfflinePageModelChanged(
     OfflinePageModel* model) {
   DCHECK_EQ(offline_page_model_, model);
   FetchOfflinePages();
 }
 
 void OfflinePageSuggestionsProvider::OfflinePageDeleted(
     int64_t offline_id,
     const offline_pages::ClientId& client_id) {
   // Because we never switch to NOT_PROVIDED dynamically, there can be no open
   // UI containing an invalidated suggestion unless the status is something
   // other than NOT_PROVIDED, so only notify invalidation in that case.
   if (recent_tabs_status_ != CategoryStatus::NOT_PROVIDED &&
-      client_id.name_space == offline_pages::kLastNNamespace) {
+      IsRecentTab(client_id)) {
     InvalidateSuggestion(recent_tabs_category_, offline_id);
   } else if (downloads_status_ != CategoryStatus::NOT_PROVIDED &&
-             client_id.name_space == offline_pages::kAsyncNamespace &&
-             base::IsValidGUID(client_id.id)) {
+             IsDownload(client_id)) {
     InvalidateSuggestion(downloads_category_, offline_id);
   }
 }
 
 void OfflinePageSuggestionsProvider::FetchOfflinePages() {
   // TODO(pke): When something other than GetAllPages is used here, the
   // dismissed IDs cleanup in OnOfflinePagesLoaded needs to be changed to avoid
   // suggestions being undismissed accidentally.
   offline_page_model_->GetAllPages(
       base::Bind(&OfflinePageSuggestionsProvider::OnOfflinePagesLoaded,
@@ skipping 12 matching lines @@
   std::set<std::string> dismissed_recent_tab_ids =
       ReadDismissedIDsFromPrefs(recent_tabs_category_);
   std::set<std::string> dismissed_download_ids =
       ReadDismissedIDsFromPrefs(downloads_category_);
   std::set<std::string> cleaned_recent_tab_ids;
   std::set<std::string> cleaned_download_ids;
   std::vector<const OfflinePageItem*> recent_tab_items;
   std::vector<const OfflinePageItem*> download_items;
   for (const OfflinePageItem& item : result) {
     std::string offline_page_id = base::IntToString(item.offline_id);
-    if (need_recent_tabs &&
-        item.client_id.name_space == offline_pages::kLastNNamespace) {
+    if (need_recent_tabs && IsRecentTab(item.client_id)) {
       if (dismissed_recent_tab_ids.count(offline_page_id))
         cleaned_recent_tab_ids.insert(offline_page_id);
       else
         recent_tab_items.push_back(&item);
     }
 
-    // TODO(pke): Use kDownloadNamespace once the OfflinePageModel uses that.
-    // The current logic is taken from DownloadUIAdapter::IsVisibleInUI.
-    // Note: This is also copied in |OfflinePageDeleted| above.
-    if (need_downloads &&
-        item.client_id.name_space == offline_pages::kAsyncNamespace &&
-        base::IsValidGUID(item.client_id.id)) {
+    if (need_downloads && IsDownload(item.client_id)) {
       if (dismissed_download_ids.count(offline_page_id))
         cleaned_download_ids.insert(offline_page_id);
       else
         download_items.push_back(&item);
     }
   }
 
   // TODO(pke): Once we have our OfflinePageModel getter and that doesn't do it
   // already, filter out duplicate URLs for recent tabs here. Duplicates for
   // downloads are fine.
 
   if (need_recent_tabs) {
     observer()->OnNewSuggestions(
         this, recent_tabs_category_,
         GetMostRecentlyVisited(recent_tabs_category_,
                                std::move(recent_tab_items)));
     if (cleaned_recent_tab_ids.size() != dismissed_recent_tab_ids.size())
       StoreDismissedIDsToPrefs(recent_tabs_category_, cleaned_recent_tab_ids);
   }
   if (need_downloads) {
     observer()->OnNewSuggestions(
         this, downloads_category_,
         GetMostRecentlyVisited(downloads_category_, std::move(download_items)));
     if (cleaned_download_ids.size() != dismissed_download_ids.size())
       StoreDismissedIDsToPrefs(downloads_category_, cleaned_download_ids);
   }
 }
 
+void OfflinePageSuggestionsProvider::OnOfflinePagesLoadedForDismissedDebugging(
+    Category category,
+    const DismissedSuggestionsCallback& callback,
+    const offline_pages::MultipleOfflinePageItemResult& result) {
+  std::set<std::string> dismissed_ids = ReadDismissedIDsFromPrefs(category);
+  std::vector<ContentSuggestion> suggestions;
+  for (const OfflinePageItem& item : result) {
+    if (category == recent_tabs_category_ && !IsRecentTab(item.client_id))
+      continue;
+    if (category == downloads_category_ && !IsDownload(item.client_id))
+      continue;
+    if (!dismissed_ids.count(base::IntToString(item.offline_id)))
+      continue;
+    suggestions.push_back(ConvertOfflinePage(category, item));
+  }
+  callback.Run(std::move(suggestions));
+}
+
 void OfflinePageSuggestionsProvider::NotifyStatusChanged(
     Category category,
     CategoryStatus new_status) {
   if (category == recent_tabs_category_) {
     DCHECK_NE(CategoryStatus::NOT_PROVIDED, recent_tabs_status_);
     if (recent_tabs_status_ == new_status)
       return;
     recent_tabs_status_ = new_status;
     observer()->OnCategoryStatusChanged(this, category, new_status);
   } else if (category == downloads_category_) {
@@ skipping 86 matching lines @@
 void OfflinePageSuggestionsProvider::StoreDismissedIDsToPrefs(
     Category category,
     const std::set<std::string>& dismissed_ids) {
   base::ListValue list;
   for (const std::string& dismissed_id : dismissed_ids)
     list.AppendString(dismissed_id);
   pref_service_->Set(GetDismissedPref(category), list);
 }
 
 }  // namespace ntp_snippets