Popular sites 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 <string>
-#include <vector>
-
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "chrome/browser/android/popular_sites.h"
 #include "chrome/browser/history/top_sites_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/search/suggestions/suggestions_service_factory.h"
 #include "chrome/browser/search/suggestions/suggestions_source.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/thumbnails/thumbnail_list_source.h"
+#include "chrome/common/chrome_switches.h"
 #include "components/history/core/browser/top_sites.h"
 #include "components/suggestions/suggestions_service.h"
 #include "components/suggestions/suggestions_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/url_data_source.h"
 #include "jni/MostVisitedSites_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
+#include "url/gurl.h"
 
 using base::android::AttachCurrentThread;
-using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 using base::android::ToJavaArrayOfStrings;
-using base::android::CheckException;
-using base::WeakPtr;
 using content::BrowserThread;
 using history::TopSites;
 using suggestions::ChromeSuggestion;
 using suggestions::SuggestionsProfile;
 using suggestions::SuggestionsService;
 using suggestions::SuggestionsServiceFactory;
 using suggestions::SyncState;
 
 namespace {
 
@@ skipping 52 matching lines @@
   ProfileSyncService* sync =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
   if (!sync)
     return SyncState::SYNC_OR_HISTORY_SYNC_DISABLED;
   return suggestions::GetSyncState(
       sync->CanSyncStart(),
       sync->IsSyncActive() && sync->ConfigurationDone(),
       sync->GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES));
 }
 
+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("NTPPopularSites");
+  base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableNTPPopularSites))
+    return false;
+  if (cmd_line->HasSwitch(switches::kEnableNTPPopularSites))
+    return true;
+  return group_name == "Enabled";
+}
+
 }  // namespace
 
 MostVisitedSites::MostVisitedSites(Profile* profile)
     : profile_(profile), num_sites_(0), initial_load_done_(false),
       num_local_thumbs_(0), num_server_thumbs_(0), num_empty_thumbs_(0),
       scoped_observer_(this), weak_ptr_factory_(this) {
   // Register the debugging page for the Suggestions Service and the thumbnails
   // debugging page.
   content::URLDataSource::Add(profile_,
                               new suggestions::SuggestionsSource(profile_));
   content::URLDataSource::Add(profile_, new ThumbnailListSource(profile_));
 
   // Register this class as an observer to the sync service. It is important to
   // be notified of changes in the sync state such as initialization, sync
   // being enabled or disabled, etc.
   ProfileSyncService* profile_sync_service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   if (profile_sync_service)
     profile_sync_service->AddObserver(this);
+
+  if (ShouldShowPopularSites()) {
+    popular_sites_.reset(new PopularSites(
+        profile_->GetRequestContext(),
+        base::Bind(&MostVisitedSites::OnPopularSitesAvailable,
+                   base::Unretained(this))));
+  }
 }
 
 MostVisitedSites::~MostVisitedSites() {
   ProfileSyncService* profile_sync_service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   if (profile_sync_service && profile_sync_service->HasObserver(this))
     profile_sync_service->RemoveObserver(this);
 }
 
 void MostVisitedSites::Destroy(JNIEnv* env, jobject obj) {
@@ skipping 196 matching lines @@
     urls.push_back(visited.url.spec());
   }
 
   // Only log impression metrics on the initial load of the NTP.
   if (!initial_load_done_) {
     for (int i = 0; i < num_tiles; ++i) {
       UMA_HISTOGRAM_SPARSE_SLOWLY(kImpressionClientHistogramName, i);
     }
   }
   mv_source_ = TOP_SITES;
+  AddPopularSites(&titles, &urls);
   NotifyMostVisitedURLsObserver(titles, urls);
 }
 
 void MostVisitedSites::OnSuggestionsProfileAvailable(
     const SuggestionsProfile& suggestions_profile) {
   int num_tiles = suggestions_profile.suggestions_size();
   // With no server suggestions, fall back to local Most Visited.
   if (num_tiles == 0) {
     InitiateTopSitesQuery();
     return;
@@ skipping 14 matching lines @@
             kImpressionServerHistogramFormat, suggestion.providers(0));
         LogHistogramEvent(histogram, i, num_sites_);
       } else {
         UMA_HISTOGRAM_SPARSE_SLOWLY(kImpressionServerHistogramName, i);
       }
     }
   }
   mv_source_ = SUGGESTIONS_SERVICE;
   // Keep a copy of the suggestions for eventual logging.
   server_suggestions_ = suggestions_profile;
+  AddPopularSites(&titles, &urls);
   NotifyMostVisitedURLsObserver(titles, urls);
 }
 
+void MostVisitedSites::AddPopularSites(std::vector<base::string16>* titles,
+                                       std::vector<std::string>* urls) {
+  if (!popular_sites_)
+    return;
+
+  DCHECK_EQ(titles->size(), urls->size());
+  if (static_cast<int>(titles->size()) >= num_sites_)
+    return;
+
+  for (const PopularSites::Site& popular_site : popular_sites_->sites()) {
+    // Skip popular sites that are already in the suggestions.
+    auto it = std::find_if(urls->begin(), urls->end(),
+        [&popular_site](const std::string& url) {
+          return GURL(url).host() == popular_site.url.host();
+        });
+    if (it != urls->end())
+      continue;
+
+    titles->push_back(popular_site.title);
+    urls->push_back(popular_site.url.spec());
+    if (static_cast<int>(titles->size()) >= num_sites_)
+      break;
+  }
+}
+
 void MostVisitedSites::NotifyMostVisitedURLsObserver(
     const std::vector<base::string16>& titles,
     const std::vector<std::string>& urls) {
   DCHECK_EQ(titles.size(), urls.size());
   if (!initial_load_done_)
     UMA_HISTOGRAM_SPARSE_SLOWLY(kNumTilesHistogramName, titles.size());
   initial_load_done_ = true;
   JNIEnv* env = AttachCurrentThread();
   Java_MostVisitedURLsObserver_onMostVisitedURLsAvailable(
       env, observer_.obj(), ToJavaArrayOfStrings(env, titles).obj(),
       ToJavaArrayOfStrings(env, urls).obj());
 }
 
+void MostVisitedSites::OnPopularSitesAvailable(bool success) {
+  if (!success) {
+    LOG(WARNING) << "Download of popular sites failed";
+    return;
+  }
+
+  if (!observer_.is_null())
+    QueryMostVisitedURLs();
+}
+
 void MostVisitedSites::RecordUMAMetrics() {
   UMA_HISTOGRAM_SPARSE_SLOWLY(kNumLocalThumbnailTilesHistogramName,
                               num_local_thumbs_);
   num_local_thumbs_ = 0;
   UMA_HISTOGRAM_SPARSE_SLOWLY(kNumEmptyTilesHistogramName, num_empty_thumbs_);
   num_empty_thumbs_ = 0;
   UMA_HISTOGRAM_SPARSE_SLOWLY(kNumServerTilesHistogramName, num_server_thumbs_);
   num_server_thumbs_ = 0;
 }
 
 void MostVisitedSites::TopSitesLoaded(history::TopSites* top_sites) {
 }
 
 void MostVisitedSites::TopSitesChanged(history::TopSites* top_sites,
                                        ChangeReason change_reason) {
   if (mv_source_ == TOP_SITES) {
     // The displayed suggestions are invalidated.
     QueryMostVisitedURLs();
   }
 }
 
 static jlong Init(JNIEnv* env, jobject obj, jobject jprofile) {
   MostVisitedSites* most_visited_sites =
       new MostVisitedSites(ProfileAndroid::FromProfileAndroid(jprofile));
   return reinterpret_cast<intptr_t>(most_visited_sites);
 }