Create //components/ntp_tiles.

chrome/browser/android/ntp/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/ntp/most_visited_sites.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/history/top_sites_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/suggestions/suggestions_service_factory.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #include "chrome/browser/thumbnails/thumbnail_list_source.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/pref_names.h"
 #include "components/history/core/browser/top_sites.h"
+#include "components/ntp_tiles/pref_names.h"
+#include "components/ntp_tiles/switches.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/url_data_source.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
@@ skipping 59 matching lines @@
   if (counter)
     counter->Add(position);
 }
 
 bool ShouldShowPopularSites() {
   // Note: It's important to query the field trial state first, to ensure that
   // UMA reports the correct group.
   const std::string group_name =
       base::FieldTrialList::FindFullName(kPopularSitesFieldTrialName);
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-  if (cmd_line->HasSwitch(switches::kDisableNTPPopularSites))
+  if (cmd_line->HasSwitch(ntp_tiles::switches::kDisableNTPPopularSites))
     return false;
-  if (cmd_line->HasSwitch(switches::kEnableNTPPopularSites))
+  if (cmd_line->HasSwitch(ntp_tiles::switches::kEnableNTPPopularSites))
     return true;
   return base::StartsWith(group_name, "Enabled",
                           base::CompareCase::INSENSITIVE_ASCII);
 }
 
 std::string GetPopularSitesCountry() {
   return variations::GetVariationParamValue(kPopularSitesFieldTrialName,
                                             "country");
 }
 
 std::string GetPopularSitesVersion() {
   return variations::GetVariationParamValue(kPopularSitesFieldTrialName,
                                             "version");
 }
 
 // Determine whether we need any popular suggestions to fill up a grid of
 // |num_tiles| tiles.
 bool NeedPopularSites(const PrefService* prefs, size_t num_tiles) {
   const base::ListValue* source_list =
-      prefs->GetList(prefs::kNTPSuggestionsIsPersonal);
+      prefs->GetList(ntp_tiles::prefs::kNTPSuggestionsIsPersonal);
   // If there aren't enough previous suggestions to fill the grid, we need
   // popular suggestions.
   if (source_list->GetSize() < num_tiles)
     return true;
   // Otherwise, if any of the previous suggestions is not personal, then also
   // get popular suggestions.
   for (size_t i = 0; i < num_tiles; ++i) {
     bool is_personal = false;
     if (source_list->GetBoolean(i, &is_personal) && !is_personal)
       return true;
@@ skipping 214 matching lines @@
   LogHistogramEvent(histogram, tile_type, NUM_TILE_TYPES);
 }
 
 void MostVisitedSites::OnURLFilterChanged() {
   QueryMostVisitedURLs();
 }
 
 // static
 void MostVisitedSites::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
-  registry->RegisterListPref(prefs::kNTPSuggestionsURL);
-  registry->RegisterListPref(prefs::kNTPSuggestionsIsPersonal);
+  registry->RegisterListPref(ntp_tiles::prefs::kNTPSuggestionsURL);
+  registry->RegisterListPref(ntp_tiles::prefs::kNTPSuggestionsIsPersonal);
 }
 
 void MostVisitedSites::QueryMostVisitedURLs() {
   SuggestionsService* suggestions_service =
       SuggestionsServiceFactory::GetForProfile(profile_);
   if (suggestions_service->FetchSuggestionsData()) {
     // A suggestions network request is on its way. We'll be called back via
     // OnSuggestionsProfileAvailable.
     return;
   }
@@ skipping 273 matching lines @@
   InsertAllSuggestions(filled_so_far, new_popular_suggestions,
                        popular_suggestions, &merged_suggestions);
   return merged_suggestions;
 }
 
 void MostVisitedSites::GetPreviousNTPSites(
     size_t num_tiles,
     std::vector<std::string>* old_sites_url,
     std::vector<bool>* old_sites_is_personal) const {
   const PrefService* prefs = profile_->GetPrefs();
-  const base::ListValue* url_list = prefs->GetList(prefs::kNTPSuggestionsURL);
+  const base::ListValue* url_list = prefs->GetList(
+      ntp_tiles::prefs::kNTPSuggestionsURL);
   const base::ListValue* source_list =
-      prefs->GetList(prefs::kNTPSuggestionsIsPersonal);
+      prefs->GetList(ntp_tiles::prefs::kNTPSuggestionsIsPersonal);
   DCHECK_EQ(url_list->GetSize(), source_list->GetSize());
   if (url_list->GetSize() < num_tiles)
     num_tiles = url_list->GetSize();
   if (num_tiles == 0) {
     // No fallback required as Personal suggestions take precedence anyway.
     return;
   }
   old_sites_url->reserve(num_tiles);
   old_sites_is_personal->reserve(num_tiles);
   for (size_t i = 0; i < num_tiles; ++i) {
     std::string url_string;
     bool success = url_list->GetString(i, &url_string);
     DCHECK(success);
     old_sites_url->push_back(url_string);
     bool is_personal;
     success = source_list->GetBoolean(i, &is_personal);
     DCHECK(success);
     old_sites_is_personal->push_back(is_personal);
   }
 }
 
 void MostVisitedSites::SaveCurrentNTPSites() {
   base::ListValue url_list;
   base::ListValue source_list;
   for (const auto& suggestion : current_suggestions_) {
     url_list.AppendString(suggestion.url.spec());
     source_list.AppendBoolean(suggestion.source != MostVisitedSites::POPULAR);
   }
   PrefService* prefs = profile_->GetPrefs();
-  prefs->Set(prefs::kNTPSuggestionsIsPersonal, source_list);
-  prefs->Set(prefs::kNTPSuggestionsURL, url_list);
+  prefs->Set(ntp_tiles::prefs::kNTPSuggestionsIsPersonal, source_list);
+  prefs->Set(ntp_tiles::prefs::kNTPSuggestionsURL, url_list);
 }
 
 // static
 std::vector<size_t> MostVisitedSites::InsertMatchingSuggestions(
     MostVisitedSites::SuggestionsPtrVector* src_suggestions,
     MostVisitedSites::SuggestionsPtrVector* dst_suggestions,
     const std::vector<std::string>& match_urls,
     const std::vector<std::string>& match_hosts) {
   std::vector<size_t> unmatched_suggestions;
   size_t num_src_suggestions = src_suggestions->size();
@@ skipping 84 matching lines @@
 
 void MostVisitedSites::TopSitesLoaded(TopSites* top_sites) {}
 
 void MostVisitedSites::TopSitesChanged(TopSites* top_sites,
                                        ChangeReason change_reason) {
   if (mv_source_ == TOP_SITES) {
     // The displayed suggestions are invalidated.
     InitiateTopSitesQuery();
   }
 }