Add favicon and publisher name to snippet cards

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 <iterator>
 #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/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/ntp_snippets/switches.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ skipping 95 matching lines @@
     const ChromeSuggestion& suggestion = suggestions.suggestions(i);
     GURL url(suggestion.url());
     if (url.is_valid())
       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.
+// Parses snippets from |list| and adds them to |snippets|. |downloaded| should
+// be true if we are adding snippets that have been freshly downloaded, and
+// false if we are loading from prefs. Returns true on success, false if
+// anything went wrong.
 bool AddSnippetsFromListValue(const base::ListValue& list,
-                              NTPSnippetsService::NTPSnippetStorage* snippets) {
+                              NTPSnippetsService::NTPSnippetStorage* snippets,
+                              bool downloaded) {
+  int num_incomplete_snippets = 0;
   for (const base::Value* const value : list) {
     const base::DictionaryValue* dict = nullptr;
     if (!value->GetAsDictionary(&dict))
       return false;
 
     const base::DictionaryValue* content = nullptr;
     if (!dict->GetDictionary(kContentInfo, &content))
       return false;
     std::unique_ptr<NTPSnippet> snippet =
         NTPSnippet::CreateFromDictionary(*content);
     if (!snippet)
       return false;
 
-    snippets->push_back(std::move(snippet));
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kAddIncompleteSnippets)) {
+      snippets->push_back(std::move(snippet));
+    } else if (snippet->is_complete()) {
+      snippets->push_back(std::move(snippet));
+    } else {
+      ++num_incomplete_snippets;
+    }
   }
+
+  if (num_incomplete_snippets > 0)
+    UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.Snippets.IncompleteSnippets",
+                                num_incomplete_snippets);
+
   return true;
 }
 
 std::unique_ptr<base::ListValue> SnippetsToListValue(
     const NTPSnippetsService::NTPSnippetStorage& snippets) {
   std::unique_ptr<base::ListValue> list(new base::ListValue);
   for (const auto& snippet : snippets) {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
     dict->Set(kContentInfo, snippet->ToDictionary());
     list->Append(std::move(dict));
@@ skipping 227 matching lines @@
 
   const base::ListValue* list = nullptr;
   if (!top_dict->GetList("recos", &list))
     return false;
 
   return LoadFromListValue(*list);
 }
 
 bool NTPSnippetsService::LoadFromListValue(const base::ListValue& list) {
   NTPSnippetStorage new_snippets;
-  if (!AddSnippetsFromListValue(list, &new_snippets))
+  if (!AddSnippetsFromListValue(list, &new_snippets, true))
     return false;
 
   // Remove new snippets that we already have, or that have been discarded.
   new_snippets.erase(
       std::remove_if(new_snippets.begin(), new_snippets.end(),
                      [this](const std::unique_ptr<NTPSnippet>& snippet) {
                        return ContainsSnippet(discarded_snippets_, snippet) ||
                               ContainsSnippet(snippets_, snippet);
                      }),
       new_snippets.end());
@@ skipping 29 matching lines @@
   LoadingSnippetsFinished();
 }
 
 void NTPSnippetsService::StoreSnippetsToPrefs() {
   pref_service_->Set(prefs::kSnippets, *SnippetsToListValue(snippets_));
 }
 
 void NTPSnippetsService::LoadDiscardedSnippetsFromPrefs() {
   discarded_snippets_.clear();
   bool success = AddSnippetsFromListValue(
-      *pref_service_->GetList(prefs::kDiscardedSnippets),
-      &discarded_snippets_);
+      *pref_service_->GetList(prefs::kDiscardedSnippets), &discarded_snippets_,
+      false);
   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;
@@ skipping 51 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::LoadingSnippetsFinished,
                                  base::Unretained(this)));
 }
 
 }  // namespace ntp_snippets