Adding filtering behavior for NTP suggestions.

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 11 matching lines @@
 #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/search/suggestions/suggestions_utils.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/sync/profile_sync_service_factory.h"
 #include "chrome/browser/thumbnails/thumbnail_list_source.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/history/core/browser/top_sites.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/suggestions/suggestions_service.h"
 #include "components/variations/variations_associated_data.h"
@@ skipping 426 matching lines @@
     return;
 
   top_sites->GetMostVisitedURLs(
       base::Bind(&MostVisitedSites::OnMostVisitedURLsAvailable,
                  weak_ptr_factory_.GetWeakPtr()),
       false);
 }
 
 void MostVisitedSites::OnMostVisitedURLsAvailable(
     const history::MostVisitedURLList& visited_list) {
+  SupervisedUserURLFilter* url_filter =
+      SupervisedUserServiceFactory::GetForProfile(profile_)
+          ->GetURLFilterForUIThread();
   MostVisitedSites::SuggestionsVector suggestions;
   size_t num_tiles =
       std::min(visited_list.size(), static_cast<size_t>(num_sites_));
   for (size_t i = 0; i < num_tiles; ++i) {
     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;

[Bernhard Bauer, 2016/02/25 11:14:48]

I would add braces around this if the condition is long enough to break it into
multiple lines.

[atanasova, 2016/02/25 11:31:32]

Done here and the other places that have the comparison (they break the same
way).

+
     suggestions.push_back(make_scoped_ptr(
         new Suggestion(visited.title, visited.url.spec(), TOP_SITES)));
   }
 
   received_most_visited_sites_ = true;
   mv_source_ = TOP_SITES;
   SaveNewNTPSuggestions(&suggestions);
   NotifyMostVisitedURLsObserver();
 }
 
 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;
   }
   if (num_sites_ < num_tiles)
     num_tiles = num_sites_;
 
+
+  SupervisedUserURLFilter* url_filter =
+      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)));
   }
 
   received_most_visited_sites_ = true;
   mv_source_ = SUGGESTIONS_SERVICE;
   SaveNewNTPSuggestions(&suggestions);
   NotifyMostVisitedURLsObserver();
 }
 
 MostVisitedSites::SuggestionsVector
 MostVisitedSites::CreateWhitelistEntryPointSuggestions(
     const MostVisitedSites::SuggestionsVector& personal_suggestions) {
   size_t num_personal_suggestions = personal_suggestions.size();
   DCHECK_LE(num_personal_suggestions, static_cast<size_t>(num_sites_));
 
   size_t num_whitelist_suggestions = num_sites_ - num_personal_suggestions;
   MostVisitedSites::SuggestionsVector whitelist_suggestions;
 
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile_);
+  SupervisedUserURLFilter* url_filter =
+      supervised_user_service->GetURLFilterForUIThread();
+
+  std::set<std::string> personal_hosts;
+  for (const auto& suggestion : personal_suggestions)
+    personal_hosts.insert(suggestion->url.host());
+  scoped_refptr<TopSites> top_sites(TopSitesFactory::GetForProfile(profile_));
 
   for (const auto& whitelist : supervised_user_service->whitelists()) {
+    // Skip blacklisted sites.
+    if (top_sites && top_sites->IsBlacklisted(whitelist->entry_point()))
+      continue;
+
+    // Skip suggestions already present.
+    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)));
     if (whitelist_suggestions.size() >= num_whitelist_suggestions)
       break;
   }
 
   return whitelist_suggestions;
 }
 
 MostVisitedSites::SuggestionsVector
 MostVisitedSites::CreatePopularSitesSuggestions(
     const MostVisitedSites::SuggestionsVector& personal_suggestions,
     const MostVisitedSites::SuggestionsVector& whitelist_suggestions) {
+  MostVisitedSites::SuggestionsVector popular_sites_suggestions;

[Bernhard Bauer, 2016/02/25 11:14:48]

I think I'd move this back down and just return an empty SuggestionsVector for
supervised users.

[atanasova, 2016/02/25 11:31:32]

Done.

+  // For child accounts popular sites suggestions will not be added.
+  if (profile_->IsChild()) {

[Bernhard Bauer, 2016/02/25 11:14:48]

Key this off IsSupervised()? Most of the code here doesn't make assumptions
about which type of supervised user we're dealing with.

[Marc Treib, 2016/02/25 11:23:13]

Well, it's essentially a product decision. Do we want popular sites for
non-child SUs?

Also, nit: No braces required here :)

[atanasova, 2016/02/25 11:31:32]

I will ping Patrick about this, I though the agreement was to disable popular
sites for child accounts until we have child specific suggestions. 

[Bernhard Bauer, 2016/02/25 11:43:29]

As I mentioned on the email thread, on Android they are equivalent right now, so
this is just about being consistent with what other code does. But then again,
I'm okay with leaving that discussion for later if you want to get this landed,
so I guess LGTM.

+    return popular_sites_suggestions;
+  }
+
   size_t num_suggestions =
       personal_suggestions.size() + whitelist_suggestions.size();
   DCHECK_LE(num_suggestions, static_cast<size_t>(num_sites_));
 
   // Collect non-blacklisted popular suggestions, skipping those already present
   // in the personal suggestions.
   size_t num_popular_sites_suggestions = num_sites_ - num_suggestions;
-  MostVisitedSites::SuggestionsVector popular_sites_suggestions;
 
   if (num_popular_sites_suggestions > 0 && popular_sites_) {
-    std::set<std::string> personal_hosts;
+    std::set<std::string> hosts;
     for (const auto& suggestion : personal_suggestions)
-      personal_hosts.insert(suggestion->url.host());
+      hosts.insert(suggestion->url.host());
+    for (const auto& suggestion : whitelist_suggestions)
+      hosts.insert(suggestion->url.host());
     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.
-      if (personal_hosts.find(host) != personal_hosts.end())
+      // 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)));
       if (popular_sites_suggestions.size() >= num_popular_sites_suggestions)
         break;
     }
   }
   return popular_sites_suggestions;
 }
@@ skipping 237 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);
 }