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();

[Marc Treib, 2016/02/25 10:34:32]

Like my late comment on the other CL: Please only do this if the profile is
supervised.

[atanasova, 2016/02/25 11:09:10]

For non-child accounts the behavior will always be ALLOW, right?
I though that adding an extra piece of logic during the comparison might seem
more complicated (e.g. if we leave this null in case of non-child accounts, or
if we want to even check whether we have a child during that check). Obviously
this is not complicated it by much, but it seemed like an additional check that
needs to be remembered in the future.

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

Well, my policy has always been to not even get a SUService if the profile isn't
supervised. But seems that Bernhard disagrees on that, so...whatever. :)

   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::ALLOW)

[Marc Treib, 2016/02/25 10:34:32]

This should probably be "== BLOCK". (WARN isn't actually used, but while it's
still there, we should treat it correctly.)

[atanasova, 2016/02/25 11:09:10]

Done.

+      continue;
+
     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) {
+  SupervisedUserURLFilter* url_filter =
+      SupervisedUserServiceFactory::GetForProfile(profile_)
+          ->GetURLFilterForUIThread();

[Marc Treib, 2016/02/25 10:34:32]

nit: Move this down to where it's actually needed.

[atanasova, 2016/02/25 11:09:10]

Done.

   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_;
 
   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::ALLOW)
+      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::ALLOW)
+      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;
+  // For unicorn child accounts popular sites suggestions will not be added.

[Marc Treib, 2016/02/25 10:34:32]

What's this "unicorn" thing you speak of? ;) (Just "child accounts" please!)

[atanasova, 2016/02/25 11:09:10]

Done.

+  if (profile_->IsChild()) {
+    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.

[Marc Treib, 2016/02/25 10:34:32]

or whitelists

[atanasova, 2016/02/25 11:09:10]

Done.

-      if (personal_hosts.find(host) != personal_hosts.end())
+      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);
 }