chrome://snippets-internals page for debugging NTP snippets.

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"
@@ skipping 50 matching lines @@
   return GetFetchingInterval(switches::kFetchingIntervalWifiSeconds,
                              kFetchingIntervalWifiSeconds);
 }
 
 base::TimeDelta GetFetchingIntervalFallback() {
   return GetFetchingInterval(switches::kFetchingIntervalFallbackSeconds,
                              kFetchingIntervalFallbackSeconds);
 }
 
 // Extracts the hosts from |suggestions| and returns them in a set.
-std::set<std::string> GetSuggestionsHosts(
+std::set<std::string> GetSuggestionsHostsImpl(
     const SuggestionsProfile& suggestions) {
   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.insert(url.host());
   }
   return hosts;
 }
@@ skipping 93 matching lines @@
     scheduler_->Unschedule();
   }
 }
 
 void NTPSnippetsService::Shutdown() {
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceShutdown());
 }
 
 void NTPSnippetsService::FetchSnippets() {
+  FetchSnippetsFromHosts(GetSuggestionsHosts());
+}
+
+void NTPSnippetsService::FetchSnippetsFromHosts(
+    const std::set<std::string>& hosts) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDontRestrict)) {
+    snippets_fetcher_->FetchSnippets(std::set<std::string>());
+    return;
+  }
+  if (!hosts.empty())
+    snippets_fetcher_->FetchSnippets(hosts);
+}
+
+void NTPSnippetsService::ClearSnippets() {
+  snippets_.clear();
+
+  StoreSnippetsToPrefs();
+
+  FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
+                    NTPSnippetsServiceLoaded());
+}
+
+std::set<std::string> NTPSnippetsService::GetSuggestionsHosts() const {
   // |suggestions_service_| can be null in tests.
-  if (!suggestions_service_)
-    return;
+  if (!suggestions_service_) {
+    std::set<std::string> empty;
+    return empty;

[Marc Treib, 2016/04/14 15:43:44]

Just 
return std::set<std::string>();
?

[jkrcal, 2016/04/14 16:41:01]

Done.

+  }
 
-  FetchSnippetsImpl(GetSuggestionsHosts(
-      suggestions_service_->GetSuggestionsDataFromCache()));
+  // TODO(treib) this should just call GetSnippetHostsFromPrefs
+  return GetSuggestionsHostsImpl(
+      suggestions_service_->GetSuggestionsDataFromCache());
 }
 
 bool NTPSnippetsService::DiscardSnippet(const GURL& url) {
   auto it = std::find_if(snippets_.begin(), snippets_.end(),
                          [&url](const scoped_ptr<NTPSnippet>& snippet) {
                            return snippet->url() == url;
                          });
   if (it == snippets_.end())
     return false;
   discarded_snippets_.push_back(std::move(*it));
   snippets_.erase(it);
   StoreDiscardedSnippetsToPrefs();
   StoreSnippetsToPrefs();
+  FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
+                    NTPSnippetsServiceLoaded());
   return true;
 }
 
+void NTPSnippetsService::ClearDiscardedSnippets() {
+  discarded_snippets_.clear();
+  StoreDiscardedSnippetsToPrefs();
+  FetchSnippets();
+}
+
 void NTPSnippetsService::AddObserver(NTPSnippetsServiceObserver* observer) {
-  observers_.AddObserver(observer);
+  if (!observers_.HasObserver(observer)) {

[Marc Treib, 2016/04/14 15:43:44]

This shouldn't be here. It's the responsibility of the other object to make sure
it doesn't register itself twice.

[jkrcal, 2016/04/14 16:41:01]

Done.

+    observers_.AddObserver(observer);
+  }
   observer->NTPSnippetsServiceLoaded();
 }
 
 void NTPSnippetsService::RemoveObserver(NTPSnippetsServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void NTPSnippetsService::OnSuggestionsChanged(
     const SuggestionsProfile& suggestions) {
-  std::set<std::string> hosts = GetSuggestionsHosts(suggestions);
+  std::set<std::string> hosts = GetSuggestionsHostsImpl(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 !hosts.count(snippet->url().host());
                      }),
       snippets_.end());
 
   StoreSnippetsToPrefs();
   StoreSnippetHostsToPrefs(hosts);
 
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceLoaded());
 
-  FetchSnippetsImpl(hosts);
+  FetchSnippetsFromHosts(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::set<std::string>& hosts) {
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDontRestrict)) {
-    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;
 
   const base::ListValue* list = nullptr;
   if (!top_dict->GetList("recos", &list))
     return false;
 
   return LoadFromListValue(*list);
@@ skipping 122 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