[NTP Snippets] Refactor background scheduling for remote suggestions

chrome/browser/ui/webui/snippets_internals_message_handler.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 "chrome/browser/ui/webui/snippets_internals_message_handler.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/ntp_snippets/content_suggestions_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_features.h"
 #include "components/ntp_snippets/category_info.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/pref_names.h"
+#include "components/ntp_snippets/remote/ntp_snippets_fetcher.h"
 #include "components/ntp_snippets/remote/remote_suggestions_provider.h"
 #include "components/ntp_snippets/switches.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/web_ui.h"
 
 using ntp_snippets::ContentSuggestion;
 using ntp_snippets::Category;
 using ntp_snippets::CategoryInfo;
 using ntp_snippets::CategoryStatus;
 using ntp_snippets::KnownCategories;
+using ntp_snippets::RemoteSuggestionsProvider;
 using ntp_snippets::UserClassifier;
 
 namespace {
 
 std::unique_ptr<base::DictionaryValue> PrepareSuggestion(
     const ContentSuggestion& suggestion,
     int index) {
   auto entry = base::MakeUnique<base::DictionaryValue>();
   entry->SetString("idWithinCategory", suggestion.id().id_within_category());
   entry->SetString("url", suggestion.url().spec());
@@ skipping 31 matching lines @@
 
 }  // namespace
 
 SnippetsInternalsMessageHandler::SnippetsInternalsMessageHandler(
     ntp_snippets::ContentSuggestionsService* content_suggestions_service,
     PrefService* pref_service)
     : content_suggestions_service_observer_(this),
       dom_loaded_(false),
       content_suggestions_service_(content_suggestions_service),
       remote_suggestions_provider_(
-          content_suggestions_service_->ntp_snippets_service()),
+          content_suggestions_service_
+              ->remote_suggestions_provider_for_debugging()),
       pref_service_(pref_service),
       weak_ptr_factory_(this) {}
 
 SnippetsInternalsMessageHandler::~SnippetsInternalsMessageHandler() {}
 
 void SnippetsInternalsMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "clearCachedSuggestions",
       base::Bind(&SnippetsInternalsMessageHandler::HandleClearCachedSuggestions,
                  base::Unretained(this)));
@@ skipping 86 matching lines @@
 
 void SnippetsInternalsMessageHandler::HandleDownload(
     const base::ListValue* args) {
   DCHECK_EQ(0u, args->GetSize());
 
   SendString("remote-status", std::string());
 
   if (!remote_suggestions_provider_)
     return;
 
-  remote_suggestions_provider_->FetchSnippetsForAllCategories();
+  remote_suggestions_provider_->ReloadSuggestions();
 }
 
 void SnippetsInternalsMessageHandler::HandleClearCachedSuggestions(
     const base::ListValue* args) {
   DCHECK_EQ(1u, args->GetSize());
 
   int category_id;
   if (!args->GetInteger(0, &category_id))
     return;
 
@@ skipping 55 matching lines @@
     const base::ListValue* args) {
   DCHECK_EQ(0u, args->GetSize());
   content_suggestions_service_->user_classifier()
       ->ClearClassificationForDebugging();
   SendClassification();
 }
 
 void SnippetsInternalsMessageHandler::FetchRemoteSuggestionsInTheBackground(
     const base::ListValue* args) {
   DCHECK_EQ(0u, args->GetSize());
-  remote_suggestions_provider_->FetchSnippetsInTheBackground();
+  remote_suggestions_provider_->RefetchInTheBackground(
+      RemoteSuggestionsProvider::FetchStatusCallback());
 }
 
 void SnippetsInternalsMessageHandler::SendAllContent() {
   SendBoolean("flag-snippets", base::FeatureList::IsEnabled(
                                    ntp_snippets::kContentSuggestionsFeature));
   SendBoolean(
       "flag-article-suggestions",
       base::FeatureList::IsEnabled(ntp_snippets::kArticleSuggestionsFeature));
   SendBoolean("flag-recent-offline-tab-suggestions",
               base::FeatureList::IsEnabled(
                   ntp_snippets::kRecentOfflineTabSuggestionsFeature));
   SendBoolean(
       "flag-asset-download-suggestions",
       base::FeatureList::IsEnabled(features::kAssetDownloadSuggestionsFeature));
   SendBoolean("flag-offline-page-download-suggestions",
               base::FeatureList::IsEnabled(
                   features::kOfflinePageDownloadSuggestionsFeature));
   SendBoolean(
       "flag-bookmark-suggestions",
       base::FeatureList::IsEnabled(ntp_snippets::kBookmarkSuggestionsFeature));
 
   SendBoolean("flag-physical-web-page-suggestions",
               base::FeatureList::IsEnabled(
                   ntp_snippets::kPhysicalWebPageSuggestionsFeature));
 
   SendClassification();
   SendLastRemoteSuggestionsBackgroundFetchTime();
 
   if (remote_suggestions_provider_) {
-    switch (
-        remote_suggestions_provider_->snippets_fetcher()->personalization()) {
+    switch (remote_suggestions_provider_
+                ->snippets_fetcher_for_testing_and_debugging()
+                ->personalization()) {
       case ntp_snippets::NTPSnippetsFetcher::Personalization::kPersonal:
         SendString("switch-personalized", "Only personalized");
         break;
       case ntp_snippets::NTPSnippetsFetcher::Personalization::kBoth:
         SendString("switch-personalized",
                    "Both personalized and non-personalized");
         break;
       case ntp_snippets::NTPSnippetsFetcher::Personalization::kNonPersonal:
         SendString("switch-personalized", "Only non-personalized");
         break;
     }
 
-    SendString(
-        "switch-fetch-url",
-        remote_suggestions_provider_->snippets_fetcher()->fetch_url().spec());
+    SendString("switch-fetch-url",
+               remote_suggestions_provider_
+                   ->snippets_fetcher_for_testing_and_debugging()
+                   ->fetch_url()
+                   .spec());
     web_ui()->CallJavascriptFunctionUnsafe(
         "chrome.SnippetsInternals.receiveJson",
-        base::StringValue(
-            remote_suggestions_provider_->snippets_fetcher()->last_json()));
+        base::StringValue(remote_suggestions_provider_
+                              ->snippets_fetcher_for_testing_and_debugging()
+                              ->last_json()));
   }
 
   SendContentSuggestions();
 }
 
 void SnippetsInternalsMessageHandler::SendClassification() {
   web_ui()->CallJavascriptFunctionUnsafe(
       "chrome.SnippetsInternals.receiveClassification",
       base::StringValue(content_suggestions_service_->user_classifier()
                             ->GetUserClassDescriptionForDebugging()),
@@ skipping 50 matching lines @@
         "dismissed-suggestions-" + base::IntToString(category.id()));
     category_entry->SetString("title", info->title());
     category_entry->SetString("status", GetCategoryStatusName(status));
     category_entry->Set("suggestions", std::move(suggestions_list));
     category_entry->Set("dismissedSuggestions", std::move(dismissed_list));
     categories_list->Append(std::move(category_entry));
   }
 
   if (remote_suggestions_provider_) {
     const std::string& status =
-        remote_suggestions_provider_->snippets_fetcher()->last_status();
+        remote_suggestions_provider_
+            ->snippets_fetcher_for_testing_and_debugging()
+            ->last_status();
     if (!status.empty())
       SendString("remote-status", "Finished: " + status);
   }
 
   base::DictionaryValue result;
   result.Set("list", std::move(categories_list));
   web_ui()->CallJavascriptFunctionUnsafe(
       "chrome.SnippetsInternals.receiveContentSuggestions", result);
 }
 
@@ skipping 13 matching lines @@
 
 void SnippetsInternalsMessageHandler::OnDismissedSuggestionsLoaded(
     Category category,
     std::vector<ContentSuggestion> dismissed_suggestions) {
   if (dismissed_state_[category] == DismissedState::HIDDEN)
     return;
   dismissed_suggestions_[category] = std::move(dismissed_suggestions);
   dismissed_state_[category] = DismissedState::VISIBLE;
   SendContentSuggestions();
 }