[NTP Snippets] Re-fetch snippets on ML changes only when the hosts actually change

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 <utility>
+
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
@@ skipping 40 matching lines @@
 base::TimeDelta GetFetchingIntervalWifi() {
   return GetFetchingInterval(switches::kFetchingIntervalWifiSeconds,
                              kFetchingIntervalWifiSeconds);
 }
 
 base::TimeDelta GetFetchingIntervalFallback() {
   return GetFetchingInterval(switches::kFetchingIntervalFallbackSeconds,
                              kFetchingIntervalFallbackSeconds);
 }
 
-std::vector<std::string> GetSuggestionsHosts(
+// Extracts the hosts from |suggestions| and returns them in a set.
+std::set<std::string> GetSuggestionsHosts(
     const SuggestionsProfile& suggestions) {
-  std::vector<std::string> hosts;
+  std::set<std::string> hosts;
   for (int i = 0; i < suggestions.suggestions_size(); ++i) {
     const ChromeSuggestion& suggestion = suggestions.suggestions(i);
     GURL url(suggestion.url());
     if (url.is_valid())
-      hosts.push_back(url.host());
+      hosts.insert(url.host());
   }
   return hosts;
 }
 
 const char kContentInfo[] = "contentInfo";
 
 // Parses snippets from |list| and adds them to |snippets|. Returns true on
 // success, false if anything went wrong.
 bool AddSnippetsFromListValue(const base::ListValue& list,
                               NTPSnippetsService::NTPSnippetStorage* snippets) {
@@ skipping 47 matching lines @@
   snippets_fetcher_subscription_ = snippets_fetcher_->AddCallback(base::Bind(
       &NTPSnippetsService::OnSnippetsDownloaded, base::Unretained(this)));
 }
 
 NTPSnippetsService::~NTPSnippetsService() {}
 
 // static
 void NTPSnippetsService::RegisterProfilePrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(prefs::kSnippets);
   registry->RegisterListPref(prefs::kDiscardedSnippets);
+  registry->RegisterListPref(prefs::kSnippetHosts);
 }
 
 void NTPSnippetsService::Init(bool enabled) {
   if (enabled) {
     // |suggestions_service_| can be null in tests.
     if (suggestions_service_) {
       suggestions_service_subscription_ = suggestions_service_->AddCallback(
           base::Bind(&NTPSnippetsService::OnSuggestionsChanged,
                      base::Unretained(this)));
     }
@@ skipping 54 matching lines @@
   if (loaded_)
     observer->NTPSnippetsServiceLoaded(this);
 }
 
 void NTPSnippetsService::RemoveObserver(NTPSnippetsServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void NTPSnippetsService::OnSuggestionsChanged(
     const SuggestionsProfile& suggestions) {
-  std::vector<std::string> hosts = GetSuggestionsHosts(suggestions);
+  std::set<std::string> hosts = GetSuggestionsHosts(suggestions);
+  if (hosts == GetSnippetHostsFromPrefs())
+    return;
 
   // Remove existing snippets that aren't in the suggestions anymore.
   snippets_.erase(
       std::remove_if(snippets_.begin(), snippets_.end(),
                      [&hosts](const scoped_ptr<NTPSnippet>& snippet) {
-                       return std::find(hosts.begin(), hosts.end(),
-                                        snippet->url().host()) == hosts.end();
+                       return !hosts.count(snippet->url().host());
                      }),
       snippets_.end());
 
   StoreSnippetsToPrefs();
+  StoreSnippetHostsToPrefs(hosts);
 
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceLoaded(this));
 
   FetchSnippetsImpl(hosts);
 }
 
 void NTPSnippetsService::OnSnippetsDownloaded(
     const std::string& snippets_json) {
   parse_json_callback_.Run(
       snippets_json, base::Bind(&NTPSnippetsService::OnJsonParsed,
                                 weak_ptr_factory_.GetWeakPtr(), snippets_json),
       base::Bind(&NTPSnippetsService::OnJsonError,
                  weak_ptr_factory_.GetWeakPtr(), snippets_json));
 }
 
 void NTPSnippetsService::OnJsonParsed(const std::string& snippets_json,
                                       scoped_ptr<base::Value> parsed) {
   LOG_IF(WARNING, !LoadFromValue(*parsed)) << "Received invalid snippets: "
                                            << snippets_json;
 }
 
 void NTPSnippetsService::OnJsonError(const std::string& snippets_json,
                                      const std::string& error) {
   LOG(WARNING) << "Received invalid JSON (" << error << "): " << snippets_json;
 }
 
 void NTPSnippetsService::FetchSnippetsImpl(
-    const std::vector<std::string>& hosts) {
+    const std::set<std::string>& hosts) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDontRestrict)) {
-    snippets_fetcher_->FetchSnippets(std::vector<std::string>());
+    snippets_fetcher_->FetchSnippets(std::set<std::string>());
     return;
   }
   if (!hosts.empty())
     snippets_fetcher_->FetchSnippets(hosts);
 }
 
 bool NTPSnippetsService::LoadFromValue(const base::Value& value) {
   const base::DictionaryValue* top_dict = nullptr;
   if (!value.GetAsDictionary(&top_dict))
     return false;
@@ skipping 59 matching lines @@
       *pref_service_->GetList(prefs::kDiscardedSnippets),
       &discarded_snippets_);
   DCHECK(success) << "Failed to parse discarded snippets from prefs";
 }
 
 void NTPSnippetsService::StoreDiscardedSnippetsToPrefs() {
   pref_service_->Set(prefs::kDiscardedSnippets,
                      *SnippetsToListValue(discarded_snippets_));
 }
 
+std::set<std::string> NTPSnippetsService::GetSnippetHostsFromPrefs() const {
+  std::set<std::string> hosts;
+  const base::ListValue* list = pref_service_->GetList(prefs::kSnippetHosts);
+  for (const base::Value* value : *list) {
+    std::string str;
+    bool success = value->GetAsString(&str);
+    DCHECK(success) << "Failed to parse snippet host from prefs";
+    hosts.insert(std::move(str));
+  }
+  return hosts;
+}
+
+void NTPSnippetsService::StoreSnippetHostsToPrefs(
+    const std::set<std::string>& hosts) {
+  base::ListValue list;
+  for (const std::string& host : hosts)
+    list.AppendString(host);
+  pref_service_->Set(prefs::kSnippetHosts, list);
+}
+
 bool NTPSnippetsService::HasDiscardedSnippet(const GURL& url) const {
   auto it = std::find_if(discarded_snippets_.begin(), discarded_snippets_.end(),
                          [&url](const scoped_ptr<NTPSnippet>& snippet) {
                            return snippet->url() == url;
                          });
   return it != discarded_snippets_.end();
 }
 
 void NTPSnippetsService::RemoveExpiredSnippets() {
   base::Time expiry = base::Time::Now();
@@ skipping 30 matching lines @@
     if (snippet->expiry_date() < next_expiry)
       next_expiry = snippet->expiry_date();
   }
   DCHECK_GT(next_expiry, expiry);
   expiry_timer_.Start(FROM_HERE, next_expiry - expiry,
                       base::Bind(&NTPSnippetsService::RemoveExpiredSnippets,
                                  base::Unretained(this)));
 }
 
 }  // namespace ntp_snippets