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/sequenced_task_runner.h"
 #include "base/prefs/public/pref_change_registrar.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/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/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 29 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 LoadManualLists(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),
+                                      base::Bind(&base::DoNothing)));
+  }
+
+  void AddStringToManualWhitelist(const std::string& url) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(
+                             &ManagedModeURLFilter::AddStringToManualWhitelist,
+                             base::Unretained(&url_filter_),
+                             url,
+                             base::Bind(&base::DoNothing)));
+  }
+
+  void AddStringToManualBlacklist(const std::string& url) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(
+                             &ManagedModeURLFilter::AddStringToManualBlacklist,
+                             base::Unretained(&url_filter_),
+                             url,
+                             base::Bind(&base::DoNothing)));
+  }
+
   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_;
 
@@ skipping 146 matching lines @@
     return CATEGORY_NOT_ON_LIST;
 
   return (*sites.begin())->category_id;
 }
 
 // static
 void ManagedMode::GetCategoryNames(CategoryList* list) {
   ManagedModeSiteList::GetCategoryNames(list);
 };
 
+// static
+scoped_ptr<base::ListValue> ManagedMode::GetWhitelist() {
+  // XXX Is this ok? GetList returns a const and we need non-const

[Bernhard Bauer, 2012/11/16 15:04:46]

Yes, it is (at least with this signature). We're passing ownership of the return
value, so it needs to be a copy.

+  return scoped_ptr<base::ListValue>(

[Bernhard Bauer, 2012/11/16 15:04:46]

You can use make_scoped_ptr() here.

[Sergiu, 2012/11/26 14:48:08]

Done.

+      GetInstance()->managed_profile_->GetPrefs()->GetList(

[Bernhard Bauer, 2012/11/16 15:04:46]

I would prefer to have public static Foo() methods that forward to private
non-static FooImpl() methods instead of accessing the members directly.

[Sergiu, 2012/11/26 14:48:08]

Done.

+          prefs::kManagedModeWhitelist)->DeepCopy()).Pass();
+}
+
+// static
+void ManagedMode::SetWhitelist(base::ListValue* whitelist) {
+    GetInstance()->managed_profile_->GetPrefs()->Set(
+        prefs::kManagedModeWhitelist, *whitelist);
+}
+
+// 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 193 matching lines @@
 }
 
 void ManagedMode::UpdateWhitelist() {
   DCHECK(managed_profile_);
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(managed_profile_)->extension_service();
   io_url_filter_context_->LoadWhitelists(
       ManagedModeSiteList::GetActiveSiteLists(extension_service));
   ui_url_filter_context_->LoadWhitelists(
       ManagedModeSiteList::GetActiveSiteLists(extension_service));
+  io_url_filter_context_->LoadManualLists(GetWhitelist(), GetBlacklist());
+  ui_url_filter_context_->LoadManualLists(GetWhitelist(), GetBlacklist());
 }
+
+void ManagedMode::AddStringToManualWhitelist(const std::string& url) {
+  GetInstance()->io_url_filter_context_->AddStringToManualWhitelist(url);
+  GetInstance()->ui_url_filter_context_->AddStringToManualWhitelist(url);
+}
+
+void ManagedMode::AddStringToManualBlacklist(const std::string& url) {
+  GetInstance()->io_url_filter_context_->AddStringToManualBlacklist(url);
+  GetInstance()->ui_url_filter_context_->AddStringToManualBlacklist(url);
+}