Support manual (white|black)list, previewing and allowing after interstitial

chrome/browser/managed_mode/managed_mode.cc

 // Copyright (c) 2012 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/managed_mode/managed_mode.h"
 
 #include "base/command_line.h"
 #include "base/prefs/public/pref_change_registrar.h"
 #include "base/sequenced_task_runner.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/managed_mode/managed_mode_site_list.h"
 #include "chrome/browser/managed_mode/managed_mode_url_filter.h"
+#include "chrome/browser/policy/url_blacklist_manager.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 30 matching lines @@
 
   void LoadWhitelists(ScopedVector<ManagedModeSiteList> site_lists) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&ManagedModeURLFilter::LoadWhitelists,
                                       base::Unretained(&url_filter_),
                                       base::Passed(&site_lists),
                                       base::Bind(&base::DoNothing)));
   }
 
+  void SetManualLists(scoped_ptr<ListValue> whitelist,
+                      scoped_ptr<ListValue> blacklist) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&ManagedModeURLFilter::SetManualLists,
+                                      base::Unretained(&url_filter_),
+                                      base::Passed(&whitelist),
+                                      base::Passed(&blacklist)));
+  }
+
+  void AddURLPatternToManualList(const bool is_whitelist,

[Bernhard Bauer, 2013/01/07 17:31:49]

const bool is a bit overkill.

[Sergiu, 2013/01/08 09:31:54]

Done.

+                                 const std::string& url) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    task_runner_->PostTask(FROM_HERE,
+        base::Bind(&ManagedModeURLFilter::AddURLPatternToManualList,
+                   base::Unretained(&url_filter_),
+                   is_whitelist,
+                   url));
+  }
+
   void ShutdownOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     bool result = task_runner_->DeleteSoon(FROM_HERE, this);
     DCHECK(result);
   }
 
  private:
   ManagedModeURLFilter url_filter_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(URLFilterContext);
 };
 
 // static
 ManagedMode* ManagedMode::GetInstance() {
   return Singleton<ManagedMode, LeakySingletonTraits<ManagedMode> >::get();
 }
 
 // static
 void ManagedMode::RegisterPrefs(PrefServiceSimple* prefs) {
   prefs->RegisterBooleanPref(prefs::kInManagedMode, false);
 }
 
 // static
 void ManagedMode::RegisterUserPrefs(PrefServiceSyncable* prefs) {
   prefs->RegisterIntegerPref(prefs::kDefaultManagedModeFilteringBehavior,
                              2,
                              PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterListPref(prefs::kManagedModeWhitelist,
+                          PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterListPref(prefs::kManagedModeBlacklist,
+                          PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 // static
 void ManagedMode::Init(Profile* profile) {
   GetInstance()->InitImpl(profile);
 }
 
 void ManagedMode::InitImpl(Profile* profile) {
   DCHECK(g_browser_process);
   DCHECK(g_browser_process->local_state());
@@ skipping 102 matching lines @@
 }
 
 const ManagedModeURLFilter* ManagedMode::GetURLFilterForIOThreadImpl() {
   return io_url_filter_context_->url_filter();
 }
 
 const ManagedModeURLFilter* ManagedMode::GetURLFilterForUIThreadImpl() {
   return ui_url_filter_context_->url_filter();
 }
 
+// static
+void ManagedMode::AddToManualList(const bool is_whitelist,
+                                  const base::ListValue& list) {
+  GetInstance()->AddToManualListImpl(is_whitelist, list);
+}
+
+void ManagedMode::AddToManualListImpl(const bool is_whitelist,
+                                      const base::ListValue& list) {
+  if (!managed_profile_)
+    return;
+
+  ListPrefUpdate pref_update(managed_profile_->GetPrefs(),
+                             is_whitelist ? prefs::kManagedModeWhitelist :
+                                            prefs::kManagedModeBlacklist);
+  ListValue* pref_list = pref_update.Get();
+
+  for (size_t i = 0; i < list.GetSize(); ++i) {
+    std::string url_pattern;
+    list.GetString(i, &url_pattern);
+
+    if (!IsInManualList(is_whitelist, url_pattern)) {
+      pref_list->AppendString(url_pattern);
+      AddURLPatternToManualList(is_whitelist, url_pattern);
+    }
+  }
+}
+
+// static
+void ManagedMode::RemoveFromManualList(const bool is_whitelist,
+                                       const base::ListValue& list) {
+  GetInstance()->RemoveFromManualListImpl(is_whitelist, list);
+}
+
+void ManagedMode::RemoveFromManualListImpl(const bool is_whitelist,
+                                           const base::ListValue& list) {
+  ListPrefUpdate pref_update(managed_profile_->GetPrefs(),
+                             is_whitelist ? prefs::kManagedModeWhitelist :
+                                            prefs::kManagedModeBlacklist);
+  ListValue* pref_list = pref_update.Get();
+
+  for (size_t i = 0; i < list.GetSize(); ++i) {
+    std::string pattern;
+    size_t out_index;
+    list.GetString(i, &pattern);
+    StringValue value_to_remove(pattern);
+
+    pref_list->Remove(value_to_remove, &out_index);
+  }
+}
+
+// static
+bool ManagedMode::IsInManualList(const bool is_whitelist,
+                                 const std::string& url_pattern) {
+  return GetInstance()->IsInManualListImpl(is_whitelist, url_pattern);
+}
+
+bool ManagedMode::IsInManualListImpl(const bool is_whitelist,
+                                     const std::string& url_pattern) {
+  StringValue pattern(url_pattern);
+  const ListValue* list = managed_profile_->GetPrefs()->GetList(
+      is_whitelist ? prefs::kManagedModeWhitelist :
+                     prefs::kManagedModeBlacklist);
+  return list->Find(pattern) != list->end();
+}
+
+// static
+scoped_ptr<base::ListValue> ManagedMode::GetBlacklist() {
+    return scoped_ptr<base::ListValue>(
+        GetInstance()->managed_profile_->GetPrefs()->GetList(
+            prefs::kManagedModeBlacklist)->DeepCopy()).Pass();
+}
+
 std::string ManagedMode::GetDebugPolicyProviderName() const {
   // Save the string space in official builds.
 #ifdef NDEBUG
   NOTREACHED();
   return std::string();
 #else
   return "Managed Mode";
 #endif
 }
 
@@ skipping 152 matching lines @@
   if (in_managed_mode) {
     int behavior_value = managed_profile_->GetPrefs()->GetInteger(
         prefs::kDefaultManagedModeFilteringBehavior);
     behavior = ManagedModeURLFilter::BehaviorFromInt(behavior_value);
   }
   io_url_filter_context_->SetDefaultFilteringBehavior(behavior);
   ui_url_filter_context_->SetDefaultFilteringBehavior(behavior);
   g_browser_process->local_state()->SetBoolean(prefs::kInManagedMode,
                                                in_managed_mode);
   if (in_managed_mode)
-    UpdateWhitelist();
+    UpdateManualListsImpl();
 
   // This causes the avatar and the profile menu to get updated.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::NotificationService::NoDetails());
 }
 
 ScopedVector<ManagedModeSiteList> ManagedMode::GetActiveSiteLists() {
   DCHECK(managed_profile_);
   ScopedVector<ManagedModeSiteList> site_lists;
   // TODO(bauerb): Get site lists from all extensions.
   return site_lists.Pass();
 }
 
 void ManagedMode::OnDefaultFilteringBehaviorChanged() {
   DCHECK(IsInManagedModeImpl());
 
   int behavior_value = managed_profile_->GetPrefs()->GetInteger(
       prefs::kDefaultManagedModeFilteringBehavior);
   ManagedModeURLFilter::FilteringBehavior behavior =
       ManagedModeURLFilter::BehaviorFromInt(behavior_value);
   io_url_filter_context_->SetDefaultFilteringBehavior(behavior);
   ui_url_filter_context_->SetDefaultFilteringBehavior(behavior);
 }
 
-void ManagedMode::UpdateWhitelist() {
+// Static
+void ManagedMode::UpdateManualLists() {
+  GetInstance()->UpdateManualListsImpl();
+}
+
+void ManagedMode::UpdateManualListsImpl() {
   io_url_filter_context_->LoadWhitelists(GetActiveSiteLists());
   ui_url_filter_context_->LoadWhitelists(GetActiveSiteLists());
+  io_url_filter_context_->SetManualLists(GetWhitelist(), GetBlacklist());
+  ui_url_filter_context_->SetManualLists(GetWhitelist(), GetBlacklist());
 }
+
+scoped_ptr<base::ListValue> ManagedMode::GetWhitelist() {
+  return make_scoped_ptr(
+      managed_profile_->GetPrefs()->GetList(
+          prefs::kManagedModeWhitelist)->DeepCopy());
+}
+
+void ManagedMode::AddURLPatternToManualList(
+    const bool is_whitelist,
+    const std::string& url_pattern) {
+  io_url_filter_context_->AddURLPatternToManualList(true, url_pattern);
+  ui_url_filter_context_->AddURLPatternToManualList(true, url_pattern);
+}