Move ManagedModePolicyProvider functionality to ManagedUserSettingsService.

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/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/managed_mode/custodian_profile_downloader_service.h"
 #include "chrome/browser/managed_mode/custodian_profile_downloader_service_factory.h"
 #include "chrome/browser/managed_mode/managed_mode_site_list.h"
+#include "chrome/browser/managed_mode/managed_user_constants.h"
 #include "chrome/browser/managed_mode/managed_user_registration_utility.h"
+#include "chrome/browser/managed_mode/managed_user_settings_service.h"
+#include "chrome/browser/managed_mode/managed_user_settings_service_factory.h"
 #include "chrome/browser/managed_mode/managed_user_sync_service.h"
 #include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
-#include "chrome/browser/policy/managed_mode_policy_provider.h"
-#include "chrome/browser/policy/profile_policy_connector.h"
-#include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_base.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/profile_sync_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/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/managed_mode_private/managed_mode_handler.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
-#include "policy/policy_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif
 
 using base::DictionaryValue;
 using base::Value;
 using content::BrowserThread;
-using policy::ManagedModePolicyProvider;
 
 namespace {
 
 const char kManagedModeFinchActive[] = "Active";
 const char kManagedModeFinchName[] = "ManagedModeLaunch";
 const char kManagedUserAccessRequestKeyPrefix[] =
     "X-ManagedUser-AccessRequests";
 const char kManagedUserAccessRequestTime[] = "timestamp";
 const char kManagedUserPseudoEmail[] = "managed_user@localhost";
 const char kOpenManagedProfileKeyPrefix[] = "X-ManagedUser-Events-OpenProfile";
@@ skipping 370 matching lines @@
 
     extensions::ExtensionResource site_list =
         extensions::ManagedModeInfo::GetContentPackSiteList(extension);
     if (!site_list.empty())
       site_lists.push_back(new ManagedModeSiteList(extension->id(), site_list));
   }
 
   return site_lists.Pass();
 }
 
-ManagedModePolicyProvider* ManagedUserService::GetPolicyProvider() {
-  policy::ProfilePolicyConnector* connector =
-      policy::ProfilePolicyConnectorFactory::GetForProfile(profile_);
-  return connector->managed_mode_policy_provider();
+ManagedUserSettingsService* ManagedUserService::GetSettingsService() {
+  return ManagedUserSettingsServiceFactory::GetForProfile(profile_);
 }
 
 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);
@@ skipping 14 matching lines @@
 }
 
 void ManagedUserService::AddAccessRequest(const GURL& url) {
   // Normalize the URL.
   GURL normalized_url = ManagedModeURLFilter::Normalize(url);
 
   // Escape the URL.
   std::string output(net::EscapeQueryParamValue(normalized_url.spec(), true));
 
   // Add the prefix.
-  std::string key = ManagedModePolicyProvider::MakeSplitSettingKey(
+  std::string key = ManagedUserSettingsService::MakeSplitSettingKey(
       kManagedUserAccessRequestKeyPrefix, output);
 
   scoped_ptr<DictionaryValue> dict(new DictionaryValue);
 
   // TODO(sergiu): Use sane time here when it's ready.
   dict->SetDouble(kManagedUserAccessRequestTime, base::Time::Now().ToJsTime());
 
-  GetPolicyProvider()->UploadItem(key, dict.PassAs<Value>());
+  GetSettingsService()->UploadItem(key, dict.PassAs<Value>());
 }
 
 ManagedUserService::ManualBehavior ManagedUserService::GetManualBehaviorForHost(
     const std::string& hostname) {
   const DictionaryValue* dict =
       profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualHosts);
   bool allow = false;
   if (!dict->GetBooleanWithoutPathExpansion(hostname, &allow))
     return MANUAL_NONE;
 
@@ skipping 48 matching lines @@
     waiting_for_sync_initialization_ = true;
   }
 }
 
 // static
 const char* ManagedUserService::GetManagedUserPseudoEmail() {
   return kManagedUserPseudoEmail;
 }
 
 void ManagedUserService::Init() {
-  ManagedModePolicyProvider* policy_provider = GetPolicyProvider();
+  ManagedUserSettingsService* settings_service = GetSettingsService();
+  DCHECK(settings_service->IsReady());
   if (!ProfileIsManaged()) {
-    if (policy_provider)
-      policy_provider->Clear();
-
+    settings_service->Clear();
     return;
   }
 
+  settings_service->Activate();
+
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kManagedUserSyncToken)) {
     InitSync(
         command_line->GetSwitchValueASCII(switches::kManagedUserSyncToken));
   }
 
   // TokenService only loads tokens automatically if we're signed in, so we have
   // to nudge it ourselves.
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   token_service->LoadTokensFromDB();
@@ skipping 17 matching lines @@
           base::Unretained(this)));
   pref_change_registrar_.Add(prefs::kManagedModeManualHosts,
       base::Bind(&ManagedUserService::UpdateManualHosts,
                  base::Unretained(this)));
   pref_change_registrar_.Add(prefs::kManagedModeManualURLs,
       base::Bind(&ManagedUserService::UpdateManualURLs,
                  base::Unretained(this)));
 
   BrowserList::AddObserver(this);
 
-  if (policy_provider)
-    policy_provider->InitLocalPolicies();
-
   // Initialize the filter.
   OnDefaultFilteringBehaviorChanged();
   UpdateSiteLists();
   UpdateManualHosts();
   UpdateManualURLs();
 
   // Call the callbacks to notify that the ManagedUserService has been
   // initialized.
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
@@ skipping 88 matching lines @@
   if (!is_profile_active_ && profile_became_active)
     RecordProfileAndBrowserEventsHelper(kOpenManagedProfileKeyPrefix);
   else if (is_profile_active_ && !profile_became_active)
     RecordProfileAndBrowserEventsHelper(kSwitchFromManagedProfileKeyPrefix);
 
   is_profile_active_ = profile_became_active;
 }
 
 void ManagedUserService::RecordProfileAndBrowserEventsHelper(
     const char* key_prefix) {
-  std::string key = ManagedModePolicyProvider::MakeSplitSettingKey(key_prefix,
+  std::string key = ManagedUserSettingsService::MakeSplitSettingKey(
+      key_prefix,
       base::Int64ToString(base::TimeTicks::Now().ToInternalValue()));
 
   scoped_ptr<DictionaryValue> dict(new DictionaryValue);
 
   // TODO(bauerb): Use sane time when ready.
   dict->SetDouble(kEventTimestamp, base::Time::Now().ToJsTime());
 
-  ManagedModePolicyProvider* provider = GetPolicyProvider();
-  // It is NULL in tests.
-  if (provider)
-    provider->UploadItem(key, dict.PassAs<Value>());
+  GetSettingsService()->UploadItem(key, dict.PassAs<Value>());
 }