Supervised users: Prototype of static client-side host blacklist.

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 "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 93 matching lines @@
     site_lists_copy.push_back((*it)->Clone());
   }
   ui_url_filter_->LoadWhitelists(site_lists.Pass());
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SupervisedUserURLFilter::LoadWhitelists,
                  io_url_filter_, base::Passed(&site_lists_copy)));
 }
 
+void SupervisedUserService::URLFilterContext::LoadBlacklist(
+    const base::FilePath& path) {
+  // For now, support loading only once. If we want to support re-load, we'll
+  // have to clear the blacklist pointer in the url filters first.
+  DCHECK_EQ(0u, blacklist_.GetEntryCount());
+  blacklist_.ReadFromFile(
+      path,
+      base::Bind(&SupervisedUserService::URLFilterContext::OnBlacklistLoaded,
+                 base::Unretained(this)));
+}
+
 void SupervisedUserService::URLFilterContext::SetManualHosts(
     scoped_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(
     scoped_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::OnBlacklistLoaded() {
+  ui_url_filter_->SetBlacklist(&blacklist_);
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&SupervisedUserURLFilter::SetBlacklist,
+                 io_url_filter_,
+                 &blacklist_));
+}
+
 SupervisedUserService::SupervisedUserService(Profile* profile)
     : profile_(profile),
       active_(false),
       delegate_(NULL),
 #if defined(ENABLE_EXTENSIONS)
       extension_registry_observer_(this),
 #endif
       waiting_for_sync_initialization_(false),
       is_profile_active_(false),
       elevated_for_testing_(false),
@@ skipping 368 matching lines @@
       SupervisedUserURLFilter::BehaviorFromInt(behavior_value);
   url_filter_context_.SetDefaultFilteringBehavior(behavior);
 }
 
 void SupervisedUserService::UpdateSiteLists() {
 #if defined(ENABLE_EXTENSIONS)
   url_filter_context_.LoadWhitelists(GetActiveSiteLists());
 #endif
 }
 
+void SupervisedUserService::LoadBlacklist(const base::FilePath& path) {
+  url_filter_context_.LoadBlacklist(path);
+}
+
 bool SupervisedUserService::AccessRequestsEnabled() {
   if (waiting_for_permissions_)
     return false;
 
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   GoogleServiceAuthError::State state = service->GetAuthError().state();
   // We allow requesting access if Sync is working or has a transient error.
   return (state == GoogleServiceAuthError::NONE ||
           state == GoogleServiceAuthError::CONNECTION_FAILED ||
@@ skipping 284 matching lines @@
   // The active user can be NULL in unit tests.
   if (user_manager::UserManager::Get()->GetActiveUser()) {
     return UTF16ToUTF8(user_manager::UserManager::Get()->GetUserDisplayName(
         user_manager::UserManager::Get()->GetActiveUser()->GetUserID()));
   }
   return std::string();
 #else
   return profile_->GetPrefs()->GetString(prefs::kProfileName);
 #endif
 }