Add ManagedUserService for profile-specific managed user data.

chrome/browser/managed_mode/managed_user_service.cc

+// Copyright (c) 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/managed_mode/managed_user_service.h"
+
+#include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.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/prefs/pref_service.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/extensions/extension_set.h"
+#include "chrome/common/pref_names.h"
+#include "content/public/browser/browser_thread.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+
+using content::BrowserThread;
+
+ManagedUserService::URLFilterContext::URLFilterContext()
+    : ui_url_filter_(new ManagedModeURLFilter),
+      io_url_filter_(new ManagedModeURLFilter) {}
+ManagedUserService::URLFilterContext::~URLFilterContext() {}
+
+ManagedModeURLFilter*
+ManagedUserService::URLFilterContext::ui_url_filter() const {
+  return ui_url_filter_.get();
+}
+
+ManagedModeURLFilter*
+ManagedUserService::URLFilterContext::io_url_filter() const {
+  return io_url_filter_.get();
+}
+
+void ManagedUserService::URLFilterContext::SetDefaultFilteringBehavior(
+    ManagedModeURLFilter::FilteringBehavior behavior) {
+  ui_url_filter_->SetDefaultFilteringBehavior(behavior);
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ManagedModeURLFilter::SetDefaultFilteringBehavior,
+                 io_url_filter_.get(),
+                 behavior));
+}
+
+void ManagedUserService::URLFilterContext::LoadWhitelists(
+    ScopedVector<ManagedModeSiteList> site_lists) {
+  // ManagedModeURLFilter::LoadWhitelists takes ownership of |site_lists|,
+  // so we make an additional copy of it.
+  /// TODO(bauerb): This is kinda ugly.
+  ScopedVector<ManagedModeSiteList> site_lists_copy;
+  for (ScopedVector<ManagedModeSiteList>::iterator it = site_lists.begin();
+       it != site_lists.end(); ++it) {
+    site_lists_copy.push_back((*it)->Clone());
+  }
+  ui_url_filter_->LoadWhitelists(site_lists.Pass());
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ManagedModeURLFilter::LoadWhitelists,
+                 io_url_filter_,
+                 base::Passed(&site_lists_copy)));
+}
+
+void ManagedUserService::URLFilterContext::SetManualLists(
+    scoped_ptr<ListValue> whitelist,
+    scoped_ptr<ListValue> blacklist) {
+  ui_url_filter_->SetManualLists(whitelist.get(), blacklist.get());
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ManagedModeURLFilter::SetManualLists,
+                 io_url_filter_,
+                 base::Owned(whitelist.release()),
+                 base::Owned(blacklist.release())));
+}
+
+void ManagedUserService::URLFilterContext::AddURLPatternToManualList(
+    const bool is_whitelist,
+    const std::string& url) {
+  ui_url_filter_->AddURLPatternToManualList(is_whitelist, url);
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ManagedModeURLFilter::AddURLPatternToManualList,
+                 io_url_filter_,
+                 is_whitelist,
+                 url));
+}
+
+ManagedUserService::ManagedUserService(Profile* profile)
+    : profile_(profile),
+      is_elevated_(false) {
+  Init();
+}
+
+ManagedUserService::~ManagedUserService() {
+}
+
+bool ManagedUserService::ProfileIsManaged() const {
+  return profile_->GetPrefs()->GetBoolean(prefs::kProfileIsManaged);
+}
+
+// static
+void ManagedUserService::RegisterUserPrefs(PrefServiceSyncable* prefs) {
+  prefs->RegisterListPref(prefs::kManagedModeWhitelist,
+                          PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterListPref(prefs::kManagedModeBlacklist,
+                          PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kDefaultManagedModeFilteringBehavior,
+                             ManagedModeURLFilter::BLOCK,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+}
+
+scoped_refptr<const ManagedModeURLFilter>
+ManagedUserService::GetURLFilterForIOThread() {
+  return url_filter_context_.io_url_filter();
+}
+
+ManagedModeURLFilter* ManagedUserService::GetURLFilterForUIThread() {
+  return url_filter_context_.ui_url_filter();
+}
+
+// Items not on any list must return -1 (CATEGORY_NOT_ON_LIST in history.js).
+// Items on a list, but with no category, must return 0 (CATEGORY_OTHER).
+#define CATEGORY_NOT_ON_LIST -1;
+#define CATEGORY_OTHER 0;
+
+int ManagedUserService::GetCategory(const GURL& url) {
+  std::vector<ManagedModeSiteList::Site*> sites;
+  GetURLFilterForUIThread()->GetSites(url, &sites);
+  if (sites.empty())
+    return CATEGORY_NOT_ON_LIST;
+
+  return (*sites.begin())->category_id;
+}
+
+// static
+void ManagedUserService::GetCategoryNames(CategoryList* list) {
+  ManagedModeSiteList::GetCategoryNames(list);
+};
+
+void ManagedUserService::AddToManualList(bool is_whitelist,
+                                         const base::ListValue& list) {
+  ListPrefUpdate pref_update(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);
+    }
+  }
+}
+
+void ManagedUserService::RemoveFromManualList(bool is_whitelist,
+                                              const base::ListValue& list) {
+  ListPrefUpdate pref_update(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);
+  }
+}
+
+bool ManagedUserService::IsInManualList(bool is_whitelist,
+                                        const std::string& url_pattern) {
+  StringValue pattern(url_pattern);
+  const ListValue* list = profile_->GetPrefs()->GetList(
+      is_whitelist ? prefs::kManagedModeWhitelist :
+                     prefs::kManagedModeBlacklist);
+  return list->Find(pattern) != list->end();
+}
+
+// static
+scoped_ptr<base::ListValue> ManagedUserService::GetBlacklist() {
+  return make_scoped_ptr(
+      profile_->GetPrefs()->GetList(prefs::kManagedModeBlacklist)->DeepCopy());
+}
+
+std::string ManagedUserService::GetDebugPolicyProviderName() const {
+  // Save the string space in official builds.
+#ifdef NDEBUG
+  NOTREACHED();
+  return std::string();
+#else
+  return "Managed User Service";
+#endif
+}
+
+bool ManagedUserService::UserMayLoad(const extensions::Extension* extension,
+                                     string16* error) const {
+  string16 tmp_error;
+  if (ExtensionManagementPolicyImpl(&tmp_error))
+    return true;
+
+  // If the extension is already loaded, we allow it, otherwise we'd unload
+  // all existing extensions.
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+
+  // |extension_service| can be NULL in a unit test.
+  if (extension_service &&
+      extension_service->GetInstalledExtension(extension->id()))
+    return true;
+
+  if (error)
+    *error = tmp_error;
+  return false;
+}
+
+bool ManagedUserService::UserMayModifySettings(
+    const extensions::Extension* extension,
+    string16* error) const {
+  return ExtensionManagementPolicyImpl(error);
+}
+
+void ManagedUserService::Observe(int type,
+                          const content::NotificationSource& source,
+                          const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_LOADED: {
+      const extensions::Extension* extension =
+          content::Details<extensions::Extension>(details).ptr();
+      if (!extension->GetContentPackSiteList().empty())
+        UpdateSiteLists();
+
+      break;
+    }
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
+      const extensions::UnloadedExtensionInfo* extension_info =
+          content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
+      if (!extension_info->extension->GetContentPackSiteList().empty())
+        UpdateSiteLists();
+
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+
+bool ManagedUserService::ExtensionManagementPolicyImpl(string16* error) const {
+  if (!ProfileIsManaged())
+    return true;
+
+  if (is_elevated_)
+    return true;
+
+  if (error)
+    *error = l10n_util::GetStringUTF16(IDS_EXTENSIONS_LOCKED_MANAGED_MODE);
+  return false;
+}
+
+ScopedVector<ManagedModeSiteList> ManagedUserService::GetActiveSiteLists() {
+  ScopedVector<ManagedModeSiteList> site_lists;
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+  // Can be NULL in unit tests.
+  if (!extension_service)
+    return site_lists.Pass();
+
+  const ExtensionSet* extensions = extension_service->extensions();
+  for (ExtensionSet::const_iterator it = extensions->begin();
+       it != extensions->end(); ++it) {
+    const extensions::Extension* extension = *it;
+    if (!extension_service->IsExtensionEnabled(extension->id()))
+      continue;
+
+    ExtensionResource site_list = extension->GetContentPackSiteList();
+    if (!site_list.empty())
+      site_lists.push_back(new ManagedModeSiteList(extension->id(), site_list));
+  }
+
+  return site_lists.Pass();
+}
+
+void ManagedUserService::OnDefaultFilteringBehaviorChanged() {
+  DCHECK(ProfileIsManaged());
+
+  int behavior_value = profile_->GetPrefs()->GetInteger(
+      prefs::kDefaultManagedModeFilteringBehavior);
+  ManagedModeURLFilter::FilteringBehavior behavior =
+      ManagedModeURLFilter::BehaviorFromInt(behavior_value);
+  url_filter_context_.SetDefaultFilteringBehavior(behavior);
+}
+
+void ManagedUserService::UpdateSiteLists() {
+  url_filter_context_.LoadWhitelists(GetActiveSiteLists());
+}
+
+void ManagedUserService::UpdateManualLists() {
+  url_filter_context_.SetManualLists(GetWhitelist(), GetBlacklist());
+}
+
+void ManagedUserService::SetElevatedForTesting(bool is_elevated) {
+  is_elevated_ = is_elevated;
+}
+
+void ManagedUserService::Init() {
+  if (!ProfileIsManaged())
+    return;
+
+  extensions::ExtensionSystem* extension_system =
+      extensions::ExtensionSystem::Get(profile_);
+  extensions::ManagementPolicy* management_policy =
+      extension_system->management_policy();
+  if (management_policy)
+    extension_system->management_policy()->RegisterProvider(this);
+
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
+                 content::Source<Profile>(profile_));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::Source<Profile>(profile_));
+  pref_change_registrar_.Init(profile_->GetPrefs());
+  pref_change_registrar_.Add(
+      prefs::kDefaultManagedModeFilteringBehavior,
+      base::Bind(
+          &ManagedUserService::OnDefaultFilteringBehaviorChanged,
+          base::Unretained(this)));
+
+  // Initialize the filter.
+  OnDefaultFilteringBehaviorChanged();
+  UpdateSiteLists();
+  UpdateManualLists();
+}
+
+scoped_ptr<base::ListValue> ManagedUserService::GetWhitelist() {
+  return make_scoped_ptr(
+      profile_->GetPrefs()->GetList(prefs::kManagedModeWhitelist)->DeepCopy());
+}
+
+void ManagedUserService::AddURLPatternToManualList(
+    bool is_whitelist,
+    const std::string& url_pattern) {
+  url_filter_context_.AddURLPatternToManualList(true, url_pattern);
+}