Convert SupervisedUserResourceThrottle to a NavigationThrottle.

chrome/browser/supervised_user/supervised_user_service.cc

 // Copyright 2014 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/supervised_user/supervised_user_service.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
 #include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/supervised_user/experimental/supervised_user_filtering_switches.h"
 #include "chrome/browser/supervised_user/permission_request_creator.h"
 #include "chrome/browser/supervised_user/supervised_user_constants.h"
 #include "chrome/browser/supervised_user/supervised_user_features.h"
+#include "chrome/browser/supervised_user/supervised_user_navigation_throttle.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_service_observer.h"
 #include "chrome/browser/supervised_user/supervised_user_settings_service.h"
 #include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_site_list.h"
 #include "chrome/browser/supervised_user/supervised_user_whitelist_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 107 matching lines @@
 base::FilePath GetBlacklistPath() {
   base::FilePath blacklist_dir;
   PathService::Get(chrome::DIR_USER_DATA, &blacklist_dir);
   return blacklist_dir.AppendASCII(kBlacklistFilename);
 }
 
 }  // namespace
 
 SupervisedUserService::~SupervisedUserService() {
   DCHECK(!did_init_ || did_shutdown_);
-  url_filter_context_.ui_url_filter()->RemoveObserver(this);
+  url_filter_.RemoveObserver(this);
 }
 
 // static
 void SupervisedUserService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kSupervisedUserApprovedExtensions);
   registry->RegisterDictionaryPref(prefs::kSupervisedUserManualHosts);
   registry->RegisterDictionaryPref(prefs::kSupervisedUserManualURLs);
   registry->RegisterIntegerPref(prefs::kDefaultSupervisedUserFilteringBehavior,
                                 SupervisedUserURLFilter::ALLOW);
@@ skipping 42 matching lines @@
     // Changing delegates isn't allowed.
     DCHECK(!delegate_);
   } else {
     // If the delegate is removed, deactivate first to give the old delegate a
     // chance to clean up.
     SetActive(false);
   }
   delegate_ = delegate;
 }
 
-scoped_refptr<const SupervisedUserURLFilter>
-SupervisedUserService::GetURLFilterForIOThread() {
-  return url_filter_context_.io_url_filter();
-}
-
-SupervisedUserURLFilter* SupervisedUserService::GetURLFilterForUIThread() {
-  return url_filter_context_.ui_url_filter();
+SupervisedUserURLFilter* SupervisedUserService::GetURLFilter() {
+  return &url_filter_;
 }
 
 SupervisedUserWhitelistService* SupervisedUserService::GetWhitelistService() {
   return whitelist_service_.get();
 }
 
 bool SupervisedUserService::AccessRequestsEnabled() {
   return FindEnabledPermissionRequestCreator(0) < permissions_creators_.size();
 }
 
 void SupervisedUserService::AddURLAccessRequest(
     const GURL& url,
     const SuccessCallback& callback) {
-  GURL effective_url = GetURLFilterForUIThread()->GetEmbeddedURL(url);
+  GURL effective_url = url_filter_.GetEmbeddedURL(url);
   if (!effective_url.is_valid())
     effective_url = url;
   AddPermissionRequestInternal(
       base::Bind(CreateURLAccessRequest,
                  SupervisedUserURLFilter::Normalize(effective_url)),
       callback, 0);
 }
 
 void SupervisedUserService::ReportURL(const GURL& url,
                                       const SuccessCallback& callback) {
@@ skipping 166 matching lines @@
 
 void SupervisedUserService::SetSafeSearchURLReporter(
     std::unique_ptr<SafeSearchURLReporter> reporter) {
   url_reporter_ = std::move(reporter);
 }
 
 bool SupervisedUserService::IncludesSyncSessionsType() const {
   return includes_sync_sessions_type_;
 }
 
-SupervisedUserService::URLFilterContext::URLFilterContext()
-    : ui_url_filter_(new SupervisedUserURLFilter),
-      io_url_filter_(new SupervisedUserURLFilter) {}
-SupervisedUserService::URLFilterContext::~URLFilterContext() {}
-
-SupervisedUserURLFilter*
-SupervisedUserService::URLFilterContext::ui_url_filter() const {
-  return ui_url_filter_.get();
-}
-
-SupervisedUserURLFilter*
-SupervisedUserService::URLFilterContext::io_url_filter() const {
-  return io_url_filter_.get();
-}
-
-void SupervisedUserService::URLFilterContext::SetDefaultFilteringBehavior(
-    SupervisedUserURLFilter::FilteringBehavior behavior) {
-  ui_url_filter_->SetDefaultFilteringBehavior(behavior);
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SupervisedUserURLFilter::SetDefaultFilteringBehavior,
-                 io_url_filter_, behavior));
-}
-
-void SupervisedUserService::URLFilterContext::LoadWhitelists(
-    const std::vector<scoped_refptr<SupervisedUserSiteList> >& site_lists) {
-  ui_url_filter_->LoadWhitelists(site_lists);
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&SupervisedUserURLFilter::LoadWhitelists,
-                                     io_url_filter_, site_lists));
-}
-
-void SupervisedUserService::URLFilterContext::SetBlacklist(
-    const SupervisedUserBlacklist* blacklist) {
-  ui_url_filter_->SetBlacklist(blacklist);
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SupervisedUserURLFilter::SetBlacklist,
-                 io_url_filter_,
-                 blacklist));
-}
-
-bool SupervisedUserService::URLFilterContext::HasBlacklist() const {
-  return ui_url_filter_->HasBlacklist();
-}
-
-void SupervisedUserService::URLFilterContext::SetManualHosts(
-    std::unique_ptr<std::map<std::string, bool>> host_map) {
-  ui_url_filter_->SetManualHosts(host_map.get());
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SupervisedUserURLFilter::SetManualHosts,
-                 io_url_filter_, base::Owned(host_map.release())));
-}
-
-void SupervisedUserService::URLFilterContext::SetManualURLs(
-    std::unique_ptr<std::map<GURL, bool>> url_map) {
-  ui_url_filter_->SetManualURLs(url_map.get());
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SupervisedUserURLFilter::SetManualURLs,
-                 io_url_filter_, base::Owned(url_map.release())));
-}
-
-void SupervisedUserService::URLFilterContext::Clear() {
-  ui_url_filter_->Clear();
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SupervisedUserURLFilter::Clear,
-                 io_url_filter_));
-}
-
-void SupervisedUserService::URLFilterContext::InitAsyncURLChecker(
-    const scoped_refptr<net::URLRequestContextGetter>& context) {
-  ui_url_filter_->InitAsyncURLChecker(context.get());
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SupervisedUserURLFilter::InitAsyncURLChecker, io_url_filter_,
-                 base::RetainedRef(context)));
-}
-
-bool SupervisedUserService::URLFilterContext::HasAsyncURLChecker() const {
-  return ui_url_filter_->HasAsyncURLChecker();
-}
-
-void SupervisedUserService::URLFilterContext::ClearAsyncURLChecker() {
-  ui_url_filter_->ClearAsyncURLChecker();
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SupervisedUserURLFilter::ClearAsyncURLChecker,
-                 io_url_filter_));
-}
-
 SupervisedUserService::SupervisedUserService(Profile* profile)
     : includes_sync_sessions_type_(true),
       profile_(profile),
       active_(false),
       delegate_(NULL),
       waiting_for_sync_initialization_(false),
       is_profile_active_(false),
       did_init_(false),
       did_shutdown_(false),
       blacklist_state_(BlacklistLoadState::NOT_LOADED),
 #if BUILDFLAG(ENABLE_EXTENSIONS)
       registry_observer_(this),
 #endif
       weak_ptr_factory_(this) {
-  url_filter_context_.ui_url_filter()->AddObserver(this);
+  url_filter_.AddObserver(this);
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   registry_observer_.Add(extensions::ExtensionRegistry::Get(profile));
 #endif
 }
 
 void SupervisedUserService::SetActive(bool active) {
   if (active_ == active)
     return;
   active_ = active;
 
@@ skipping 99 matching lines @@
         prefs::kDefaultSupervisedUserFilteringBehavior);
 #if BUILDFLAG(ENABLE_EXTENSIONS)
     pref_change_registrar_.Remove(prefs::kSupervisedUserApprovedExtensions);
 #endif
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualHosts);
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualURLs);
     for (const char* pref : kCustodianInfoPrefs) {
       pref_change_registrar_.Remove(pref);
     }
 
-    url_filter_context_.Clear();
+    url_filter_.Clear();
     for (SupervisedUserServiceObserver& observer : observer_list_)
       observer.OnURLFilterChanged();
 
 #if !defined(OS_ANDROID)
     if (waiting_for_sync_initialization_)
       ProfileSyncServiceFactory::GetForProfile(profile_)->RemoveObserver(this);
 
     // TODO(bauerb): Get rid of the platform-specific #ifdef here.
     // http://crbug.com/313377
     BrowserList::RemoveObserver(this);
@@ skipping 133 matching lines @@
 
 void SupervisedUserService::OnSupervisedUserIdChanged() {
   SetActive(ProfileIsSupervised());
 }
 
 void SupervisedUserService::OnDefaultFilteringBehaviorChanged() {
   int behavior_value = profile_->GetPrefs()->GetInteger(
       prefs::kDefaultSupervisedUserFilteringBehavior);
   SupervisedUserURLFilter::FilteringBehavior behavior =
       SupervisedUserURLFilter::BehaviorFromInt(behavior_value);
-  url_filter_context_.SetDefaultFilteringBehavior(behavior);
+  url_filter_.SetDefaultFilteringBehavior(behavior);
 
   for (SupervisedUserServiceObserver& observer : observer_list_)
     observer.OnURLFilterChanged();
 }
 
 void SupervisedUserService::OnSafeSitesSettingChanged() {
   bool use_blacklist = supervised_users::IsSafeSitesBlacklistEnabled(profile_);
-  if (use_blacklist != url_filter_context_.HasBlacklist()) {
+  if (use_blacklist != url_filter_.HasBlacklist()) {
     if (use_blacklist && blacklist_state_ == BlacklistLoadState::NOT_LOADED) {
       LoadBlacklist(GetBlacklistPath(), GURL(kBlacklistURL));
     } else if (!use_blacklist ||
                blacklist_state_ == BlacklistLoadState::LOADED) {
       // Either the blacklist was turned off, or it was turned on but has
       // already been loaded previously. Just update the setting.
       UpdateBlacklist();
     }
     // Else: The blacklist was enabled, but the load is already in progress.
     // Do nothing - we'll check the setting again when the load finishes.
   }
 
   bool use_online_check =
       supervised_users::IsSafeSitesOnlineCheckEnabled(profile_);
-  if (use_online_check != url_filter_context_.HasAsyncURLChecker()) {
+  if (use_online_check != url_filter_.HasAsyncURLChecker()) {
     if (use_online_check)
-      url_filter_context_.InitAsyncURLChecker(profile_->GetRequestContext());
+      url_filter_.InitAsyncURLChecker(profile_->GetRequestContext());
     else
-      url_filter_context_.ClearAsyncURLChecker();
+      url_filter_.ClearAsyncURLChecker();
   }
 }
 
 void SupervisedUserService::OnSiteListsChanged(
     const std::vector<scoped_refptr<SupervisedUserSiteList> >& site_lists) {
   whitelists_ = site_lists;
-  url_filter_context_.LoadWhitelists(site_lists);
+  url_filter_.LoadWhitelists(site_lists);
 }
 
 void SupervisedUserService::LoadBlacklist(const base::FilePath& path,
                                           const GURL& url) {
   DCHECK(blacklist_state_ == BlacklistLoadState::NOT_LOADED);
   blacklist_state_ = BlacklistLoadState::LOAD_STARTED;
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN).get(),
       FROM_HERE,
@@ skipping 74 matching lines @@
 }
 
 void SupervisedUserService::OnBlacklistLoaded() {
   DCHECK(blacklist_state_ == BlacklistLoadState::LOAD_STARTED);
   blacklist_state_ = BlacklistLoadState::LOADED;
   UpdateBlacklist();
 }
 
 void SupervisedUserService::UpdateBlacklist() {
   bool use_blacklist = supervised_users::IsSafeSitesBlacklistEnabled(profile_);
-  url_filter_context_.SetBlacklist(use_blacklist ? &blacklist_ : nullptr);
+  url_filter_.SetBlacklist(use_blacklist ? &blacklist_ : nullptr);
   for (SupervisedUserServiceObserver& observer : observer_list_)
     observer.OnURLFilterChanged();
 }
 
 void SupervisedUserService::UpdateManualHosts() {
   const base::DictionaryValue* dict =
       profile_->GetPrefs()->GetDictionary(prefs::kSupervisedUserManualHosts);
-  std::unique_ptr<std::map<std::string, bool>> host_map(
-      new std::map<std::string, bool>());
+  std::map<std::string, bool> host_map;
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     bool allow = false;
     bool result = it.value().GetAsBoolean(&allow);
     DCHECK(result);
-    (*host_map)[it.key()] = allow;
+    host_map[it.key()] = allow;
   }
-  url_filter_context_.SetManualHosts(std::move(host_map));
+  url_filter_.SetManualHosts(std::move(host_map));
 
   for (SupervisedUserServiceObserver& observer : observer_list_)
     observer.OnURLFilterChanged();
 }
 
 void SupervisedUserService::UpdateManualURLs() {
   const base::DictionaryValue* dict =
       profile_->GetPrefs()->GetDictionary(prefs::kSupervisedUserManualURLs);
-  std::unique_ptr<std::map<GURL, bool>> url_map(new std::map<GURL, bool>());
+  std::map<GURL, bool> url_map;
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     bool allow = false;
     bool result = it.value().GetAsBoolean(&allow);
     DCHECK(result);
-    (*url_map)[GURL(it.key())] = allow;
+    url_map[GURL(it.key())] = allow;
   }
-  url_filter_context_.SetManualURLs(std::move(url_map));
+  url_filter_.SetManualURLs(std::move(url_map));
 
   for (SupervisedUserServiceObserver& observer : observer_list_)
     observer.OnURLFilterChanged();
 }
 
 std::string SupervisedUserService::GetSupervisedUserName() const {
 #if defined(OS_CHROMEOS)
   // The active user can be NULL in unit tests.
   if (user_manager::UserManager::Get()->GetActiveUser()) {
     return UTF16ToUTF8(user_manager::UserManager::Get()->GetUserDisplayName(
@@ skipping 321 matching lines @@
     content::RecordAction(UserMetricsAction("ManagedUsers_SwitchProfile"));
 
   is_profile_active_ = profile_became_active;
 }
 #endif  // !defined(OS_ANDROID)
 
 void SupervisedUserService::OnSiteListUpdated() {
   for (SupervisedUserServiceObserver& observer : observer_list_)
     observer.OnURLFilterChanged();
 }