Start using the whitelist icon on the NTP.

chrome/browser/android/most_visited_sites.cc

 // Copyright 2013 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/android/most_visited_sites.h"
 
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
@@ skipping 146 matching lines @@
     if (source_list->GetBoolean(i, &is_personal) && !is_personal)
       return true;
   }
   // The whole grid is already filled with personal suggestions, no point in
   // bothering with popular ones.
   return false;
 }
 
 }  // namespace
 
-MostVisitedSites::Suggestion::Suggestion(const base::string16& title,
-                                         const std::string& url,
-                                         MostVisitedSource source)
-    : title(title), url(url), source(source), provider_index(-1) {}
+namespace {
+class SuggestionBuilder {

[Marc Treib, 2016/03/16 11:06:03]

nit: empty line after "namespace {" please.

[atanasova, 2016/03/16 17:58:17]

Done.

+ public:
+  SuggestionBuilder(const base::string16& title,
+                    const GURL& url,
+                    MostVisitedSites::MostVisitedSource source);
+  ~SuggestionBuilder();
 
-MostVisitedSites::Suggestion::Suggestion(const base::string16& title,
-                                         const GURL& url,
-                                         MostVisitedSource source)
-    : title(title), url(url), source(source), provider_index(-1) {}
+  void SetWhitelistIconPath(const base::FilePath& whitelist_icon_path);
 
-MostVisitedSites::Suggestion::Suggestion(const base::string16& title,
-                                         const std::string& url,
-                                         MostVisitedSource source,
-                                         int provider_index)
-    : title(title), url(url), source(source), provider_index(provider_index) {
-  DCHECK_EQ(MostVisitedSites::SUGGESTIONS_SERVICE, source);
+  void SetProviderIndex(int provider_index);
+
+  scoped_ptr<MostVisitedSites::Suggestion> Build();
+
+ private:
+  base::string16 title_;
+  GURL url_;

[Marc Treib, 2016/03/16 11:06:03]

Maybe this should store references to the title and url, to avoid the extra
copy?

+  MostVisitedSites::MostVisitedSource source_;
+  base::FilePath whitelist_icon_path_;
+  int provider_index_;
+};
+
+SuggestionBuilder::SuggestionBuilder(const base::string16& title,
+                                     const GURL& url,
+                                     MostVisitedSites::MostVisitedSource source)
+    : title_(title), url_(url), source_(source), provider_index_(-1) {}
+
+SuggestionBuilder::~SuggestionBuilder() {}
+
+void SuggestionBuilder::SetWhitelistIconPath(
+    const base::FilePath& whitelist_icon_path) {
+  whitelist_icon_path_ = whitelist_icon_path;
 }
 
+void SuggestionBuilder::SetProviderIndex(int provider_index) {
+  provider_index_ = provider_index;
+}
+
+scoped_ptr<MostVisitedSites::Suggestion> SuggestionBuilder::Build() {
+  return make_scoped_ptr(new MostVisitedSites::Suggestion(
+      title_, url_, source_, whitelist_icon_path_, provider_index_));
+}
+
+}  // namespace
+
+MostVisitedSites::Suggestion::Suggestion(
+    const base::string16& title,
+    const GURL& url,
+    MostVisitedSource source,
+    const base::FilePath& whitelist_icon_path,
+    int provider_index)
+    : title(title),
+      url(url),
+      source(source),
+      whitelist_icon_path(whitelist_icon_path),
+      provider_index(provider_index) {}
+
 MostVisitedSites::Suggestion::~Suggestion() {}
 
 std::string MostVisitedSites::Suggestion::GetSourceHistogramName() const {
   switch (source) {
     case MostVisitedSites::TOP_SITES:
       return kHistogramClientName;
     case MostVisitedSites::POPULAR:
       return kHistogramPopularName;
     case MostVisitedSites::WHITELIST:
       return kHistogramWhitelistName;
@@ skipping 291 matching lines @@
     const history::MostVisitedURL& visited = visited_list[i];
     if (visited.url.is_empty()) {
       num_tiles = i;
       break;  // This is the signal that there are no more real visited sites.
     }
     if (url_filter->GetFilteringBehaviorForURL(visited.url) ==
         SupervisedUserURLFilter::FilteringBehavior::BLOCK) {
       continue;
     }
 
-    suggestions.push_back(make_scoped_ptr(
-        new Suggestion(visited.title, visited.url.spec(), TOP_SITES)));
+    SuggestionBuilder* builder =
+        new SuggestionBuilder(visited.title, visited.url, TOP_SITES);

[Marc Treib, 2016/03/16 11:06:03]

Memleak! Just
SuggestionBuilder builder(...);
please!

[atanasova, 2016/03/16 17:58:17]

Done.

+
+    suggestions.push_back(builder->Build());
   }
 
   received_most_visited_sites_ = true;
   mv_source_ = TOP_SITES;
   SaveNewNTPSuggestions(&suggestions);
   NotifyMostVisitedURLsObserver();
 }
 
 void MostVisitedSites::OnSuggestionsProfileAvailable(
     const SuggestionsProfile& suggestions_profile) {
@@ skipping 10 matching lines @@
       SupervisedUserServiceFactory::GetForProfile(profile_)
           ->GetURLFilterForUIThread();
   MostVisitedSites::SuggestionsVector suggestions;
   for (int i = 0; i < num_tiles; ++i) {
     const ChromeSuggestion& suggestion = suggestions_profile.suggestions(i);
     if (url_filter->GetFilteringBehaviorForURL(GURL(suggestion.url())) ==
         SupervisedUserURLFilter::FilteringBehavior::BLOCK) {
       continue;
     }
 
-    suggestions.push_back(make_scoped_ptr(new Suggestion(
-        base::UTF8ToUTF16(suggestion.title()), suggestion.url(),
-        SUGGESTIONS_SERVICE,
-        suggestion.providers_size() > 0 ? suggestion.providers(0) : -1)));
+    const base::string16& title = base::UTF8ToUTF16(suggestion.title());
+    SuggestionBuilder* builder = new SuggestionBuilder(
+        title, GURL(suggestion.url()), SUGGESTIONS_SERVICE);
+    builder->SetProviderIndex(
+        suggestion.providers_size() > 0 ? suggestion.providers(0) : -1);
+
+    suggestions.push_back(builder->Build());
   }
 
   received_most_visited_sites_ = true;
   mv_source_ = SUGGESTIONS_SERVICE;
   SaveNewNTPSuggestions(&suggestions);
   NotifyMostVisitedURLsObserver();
 }
 
 MostVisitedSites::SuggestionsVector
 MostVisitedSites::CreateWhitelistEntryPointSuggestions(
@@ skipping 23 matching lines @@
     if (personal_hosts.find(whitelist->entry_point().host()) !=
         personal_hosts.end())
       continue;
 
     // Skip whitelist entry points that are manually blocked.
     if (url_filter->GetFilteringBehaviorForURL(whitelist->entry_point()) ==
         SupervisedUserURLFilter::FilteringBehavior::BLOCK) {
       continue;
     }
 
-    whitelist_suggestions.push_back(make_scoped_ptr(new Suggestion(
-        whitelist->title(), whitelist->entry_point(), WHITELIST)));
+    SuggestionBuilder* builder = new SuggestionBuilder(
+        whitelist->title(), whitelist->entry_point(), WHITELIST);
+    builder->SetWhitelistIconPath(whitelist->large_icon_path());
+
+    whitelist_suggestions.push_back(builder->Build());
     if (whitelist_suggestions.size() >= num_whitelist_suggestions)
       break;
   }
 
   return whitelist_suggestions;
 }
 
 MostVisitedSites::SuggestionsVector
 MostVisitedSites::CreatePopularSitesSuggestions(
     const MostVisitedSites::SuggestionsVector& personal_suggestions,
@@ skipping 20 matching lines @@
     scoped_refptr<TopSites> top_sites(TopSitesFactory::GetForProfile(profile_));
     for (const PopularSites::Site& popular_site : popular_sites_->sites()) {
       // Skip blacklisted sites.
       if (top_sites && top_sites->IsBlacklisted(popular_site.url))
         continue;
       std::string host = popular_site.url.host();
       // Skip suggestions already present in personal or whitelists.
       if (hosts.find(host) != hosts.end())
         continue;
 
-      popular_sites_suggestions.push_back(make_scoped_ptr(
-          new Suggestion(popular_site.title, popular_site.url, POPULAR)));
+      SuggestionBuilder* builder = new SuggestionBuilder(
+          popular_site.title, GURL(popular_site.url), POPULAR);
+
+      popular_sites_suggestions.push_back(builder->Build());
       if (popular_sites_suggestions.size() >= num_popular_sites_suggestions)
         break;
     }
   }
   return popular_sites_suggestions;
 }
 
 void MostVisitedSites::SaveNewNTPSuggestions(
     MostVisitedSites::SuggestionsVector* personal_suggestions) {
   MostVisitedSites::SuggestionsVector whitelist_suggestions =
@@ skipping 166 matching lines @@
 void MostVisitedSites::NotifyMostVisitedURLsObserver() {
   size_t num_suggestions = current_suggestions_.size();
   if (received_most_visited_sites_ && received_popular_sites_ &&
       !recorded_uma_) {
     RecordImpressionUMAMetrics();
     UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.NumberOfTiles", num_suggestions);
     recorded_uma_ = true;
   }
   std::vector<base::string16> titles;
   std::vector<std::string> urls;
+  std::vector<std::string> whitelist_icon_paths;
   titles.reserve(num_suggestions);
   urls.reserve(num_suggestions);
   for (const auto& suggestion : current_suggestions_) {
     titles.push_back(suggestion->title);
     urls.push_back(suggestion->url.spec());
+    whitelist_icon_paths.push_back(suggestion->whitelist_icon_path.value());
   }
   JNIEnv* env = AttachCurrentThread();
   DCHECK_EQ(titles.size(), urls.size());
   Java_MostVisitedURLsObserver_onMostVisitedURLsAvailable(
       env, observer_.obj(), ToJavaArrayOfStrings(env, titles).obj(),
-      ToJavaArrayOfStrings(env, urls).obj());
+      ToJavaArrayOfStrings(env, urls).obj(),
+      ToJavaArrayOfStrings(env, whitelist_icon_paths).obj());
 }
 
 void MostVisitedSites::OnPopularSitesAvailable(bool success) {
   received_popular_sites_ = true;
 
   if (!success) {
     LOG(WARNING) << "Download of popular sites failed";
     return;
   }
 
@@ skipping 36 matching lines @@
   }
 }
 
 static jlong Init(JNIEnv* env,
                   const JavaParamRef<jobject>& obj,
                   const JavaParamRef<jobject>& jprofile) {
   MostVisitedSites* most_visited_sites =
       new MostVisitedSites(ProfileAndroid::FromProfileAndroid(jprofile));
   return reinterpret_cast<intptr_t>(most_visited_sites);
 }