Start managed_mode refactor.

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/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/managed_mode/permission_request_creator_sync.h"
 #include "chrome/browser/managed_mode/supervised_user_pref_mapping_service.h"
 #include "chrome/browser/managed_mode/supervised_user_pref_mapping_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
+#include "chrome/browser/themes/theme_service.h"
+#include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/managed_mode_private/managed_mode_handler.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 73 matching lines @@
   ui_url_filter_->SetManualURLs(url_map.get());
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ManagedModeURLFilter::SetManualURLs,
                  io_url_filter_, base::Owned(url_map.release())));
 }
 
 ManagedUserService::ManagedUserService(Profile* profile)
     : profile_(profile),
+      active_(false),
+      delegate_(NULL),
       extension_registry_observer_(this),
       waiting_for_sync_initialization_(false),
       is_profile_active_(false),
       elevated_for_testing_(false),
       did_shutdown_(false),
       waiting_for_permissions_(false),
       weak_ptr_factory_(this) {
 }
 
 ManagedUserService::~ManagedUserService() {
   DCHECK(did_shutdown_);
 }
 
 void ManagedUserService::Shutdown() {
   did_shutdown_ = true;
   if (ProfileIsManaged()) {
     content::RecordAction(UserMetricsAction("ManagedUsers_QuitBrowser"));
-#if !defined(OS_ANDROID)
-    // TODO(bauerb): Get rid of the platform-specific #ifdef here.
-    // http://crbug.com/313377
-    BrowserList::RemoveObserver(this);
-#endif
   }
-
-  if (!waiting_for_sync_initialization_)
-    return;
-
-  ProfileSyncService* sync_service =
-        ProfileSyncServiceFactory::GetForProfile(profile_);
-  sync_service->RemoveObserver(this);
+  SetActive(false);
 }
 
 bool ManagedUserService::ProfileIsManaged() const {
   return profile_->IsManaged();
 }
 
 // static
 void ManagedUserService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
@@ skipping 26 matching lines @@
   if (!is_managed)
     return;
 
   std::string managed_user_id = prefs->GetString(prefs::kManagedUserId);
   if (!managed_user_id.empty())
     return;
 
   prefs->SetString(prefs::kManagedUserId, "Dummy ID");
 }
 
+void ManagedUserService::SetDelegate(Delegate* delegate) {
+  if (delegate_ == delegate)
+    return;
+  // If the delegate changed, deactivate first to give the old delegate a chance
+  // to clean up.
+  SetActive(false);
+  delegate_ = delegate;
+}
+
 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).
@@ skipping 98 matching lines @@
   return false;
 }
 
 bool ManagedUserService::UserMayModifySettings(
     const extensions::Extension* extension,
     base::string16* error) const {
   return ExtensionManagementPolicyImpl(extension, error);
 }
 
 void ManagedUserService::OnStateChanged() {
+  DCHECK(profile_->GetProfileName().empty());
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   if (waiting_for_sync_initialization_ && service->sync_initialized()) {
     waiting_for_sync_initialization_ = false;
     service->RemoveObserver(this);
     SetupSync();
     return;
   }
 
   DLOG_IF(ERROR, service->GetAuthError().state() ==
@@ skipping 11 matching lines @@
 void ManagedUserService::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
   if (!extensions::ManagedModeInfo::GetContentPackSiteList(extension).empty()) {
     UpdateSiteLists();
   }
 }
 
 void ManagedUserService::SetupSync() {
+  DCHECK(profile_->GetProfileName().empty());
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   DCHECK(service->sync_initialized());
 
   bool sync_everything = false;
   syncer::ModelTypeSet synced_datatypes;
   synced_datatypes.Put(syncer::MANAGED_USER_SETTINGS);
   service->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Notify ProfileSyncService that we are done with configuration.
@@ skipping 39 matching lines @@
     }
   }
 
   return site_lists.Pass();
 }
 
 ManagedUserSettingsService* ManagedUserService::GetSettingsService() {
   return ManagedUserSettingsServiceFactory::GetForProfile(profile_);
 }
 
+void ManagedUserService::OnManagedUserIdChanged() {
+  std::string managed_user_id =
+      profile_->GetPrefs()->GetString(prefs::kManagedUserId);
+  SetActive(!managed_user_id.empty());
+}
+
 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 63 matching lines @@
   const base::DictionaryValue* dict =
       profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     GURL url(it.key());
     if (url.host() == host)
       urls->push_back(url);
   }
 }
 
 void ManagedUserService::InitSync(const std::string& refresh_token) {
+  DCHECK(profile_->GetProfileName().empty());
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   // Tell the sync service that setup is in progress so we don't start syncing
   // until we've finished configuration.
   service->SetSetupInProgress(true);
 
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   token_service->UpdateCredentials(managed_users::kManagedUserPseudoEmail,
                                    refresh_token);
 
   // Continue in SetupSync() once the Sync backend has been initialized.
   if (service->sync_initialized()) {
     SetupSync();
   } else {
     ProfileSyncServiceFactory::GetForProfile(profile_)->AddObserver(this);
     waiting_for_sync_initialization_ = true;
   }
 }
 
 void ManagedUserService::Init() {
-  ManagedUserSettingsService* settings_service = GetSettingsService();
-  DCHECK(settings_service->IsReady());
-  if (!ProfileIsManaged()) {
-    settings_service->Clear();
+  DCHECK(GetSettingsService()->IsReady());
+
+  pref_change_registrar_.Init(profile_->GetPrefs());
+  pref_change_registrar_.Add(
+      prefs::kManagedUserId,
+      base::Bind(&ManagedUserService::OnManagedUserIdChanged,
+          base::Unretained(this)));
+
+  SetActive(ProfileIsManaged());
+}
+
+void ManagedUserService::SetActive(bool active) {
+  if (active_ == active)
     return;
+  active_ = active;
+
+  if (!delegate_ || !delegate_->SetActive(active_)) {
+    if (active_) {
+      SupervisedUserPrefMappingServiceFactory::GetForBrowserContext(profile_)
+          ->Init();
+
+      CommandLine* command_line = CommandLine::ForCurrentProcess();
+      if (command_line->HasSwitch(switches::kManagedUserSyncToken)) {
+        InitSync(
+            command_line->GetSwitchValueASCII(switches::kManagedUserSyncToken));
+      }
+
+      ProfileOAuth2TokenService* token_service =
+          ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
+      token_service->LoadCredentials(managed_users::kManagedUserPseudoEmail);
+    }
   }
 
-  settings_service->Activate();
+  // Now activate/deactivate anything not handled by the delegate yet.
 
-  SupervisedUserPrefMappingServiceFactory::GetForBrowserContext(profile_)
-      ->Init();
-
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kManagedUserSyncToken)) {
-    InitSync(
-        command_line->GetSwitchValueASCII(switches::kManagedUserSyncToken));
+  // Re-set the default theme to turn the SU theme on/off.
+  ThemeService* theme_service = ThemeServiceFactory::GetForProfile(profile_);
+  if (theme_service->UsingDefaultTheme() || theme_service->UsingSystemTheme()) {
+    ThemeServiceFactory::GetForProfile(profile_)->UseDefaultTheme();
   }
 
-  ProfileOAuth2TokenService* token_service =
-      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
-  token_service->LoadCredentials(managed_users::kManagedUserPseudoEmail);
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kPermissionRequestApiUrl)) {
-    permissions_creator_ =
-        PermissionRequestCreatorApiary::CreateWithProfile(profile_);
-  } else {
-    PrefService* pref_service = profile_->GetPrefs();
-    permissions_creator_.reset(new PermissionRequestCreatorSync(
-        settings_service,
-        ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(profile_),
-        pref_service->GetString(prefs::kProfileName),
-        pref_service->GetString(prefs::kManagedUserId)));
-  }
+  ManagedUserSettingsService* settings_service = GetSettingsService();
+  settings_service->SetActive(active_);
 
   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);
 
-  extension_registry_observer_.Add(
-      extensions::ExtensionRegistry::Get(profile_));
+  if (active_) {
+    if (CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kPermissionRequestApiUrl)) {
+      permissions_creator_ =
+          PermissionRequestCreatorApiary::CreateWithProfile(profile_);
+    } else {
+      PrefService* pref_service = profile_->GetPrefs();
+      permissions_creator_.reset(new PermissionRequestCreatorSync(
+          settings_service,
+          ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(
+              profile_),
+          pref_service->GetString(prefs::kProfileName),
+          pref_service->GetString(prefs::kManagedUserId)));
+    }
 
-  pref_change_registrar_.Init(profile_->GetPrefs());
-  pref_change_registrar_.Add(
-      prefs::kDefaultManagedModeFilteringBehavior,
-      base::Bind(&ManagedUserService::OnDefaultFilteringBehaviorChanged,
-          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)));
+    if (management_policy)
+      management_policy->RegisterProvider(this);
+
+    extension_registry_observer_.Add(
+        extensions::ExtensionRegistry::Get(profile_));
+
+    pref_change_registrar_.Add(
+        prefs::kDefaultManagedModeFilteringBehavior,
+        base::Bind(&ManagedUserService::OnDefaultFilteringBehaviorChanged,
+            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)));
+
+    // Initialize the filter.
+    OnDefaultFilteringBehaviorChanged();
+    UpdateSiteLists();
+    UpdateManualHosts();
+    UpdateManualURLs();
 
 #if !defined(OS_ANDROID)
-  // TODO(bauerb): Get rid of the platform-specific #ifdef here.
-  // http://crbug.com/313377
-  BrowserList::AddObserver(this);
+    // TODO(bauerb): Get rid of the platform-specific #ifdef here.
+    // http://crbug.com/313377
+    BrowserList::AddObserver(this);
 #endif
+  } else {
+    permissions_creator_.reset();
 
-  // Initialize the filter.
-  OnDefaultFilteringBehaviorChanged();
-  UpdateSiteLists();
-  UpdateManualHosts();
-  UpdateManualURLs();
+    if (management_policy)
+      management_policy->UnregisterProvider(this);
+
+    extension_registry_observer_.RemoveAll();
+
+    pref_change_registrar_.Remove(prefs::kDefaultManagedModeFilteringBehavior);
+    pref_change_registrar_.Remove(prefs::kManagedModeManualHosts);
+    pref_change_registrar_.Remove(prefs::kManagedModeManualURLs);
+
+    if (waiting_for_sync_initialization_) {
+      ProfileSyncService* sync_service =
+          ProfileSyncServiceFactory::GetForProfile(profile_);
+      sync_service->RemoveObserver(this);
+    }
+
+#if !defined(OS_ANDROID)
+    // TODO(bauerb): Get rid of the platform-specific #ifdef here.
+    // http://crbug.com/313377
+    BrowserList::RemoveObserver(this);
+#endif
+  }
 }
 
 void ManagedUserService::RegisterAndInitSync(
     ManagedUserRegistrationUtility* registration_utility,
     Profile* custodian_profile,
     const std::string& managed_user_id,
     const AuthErrorCallback& callback) {
   DCHECK(ProfileIsManaged());
+  DCHECK(profile_->GetProfileName().empty());
   DCHECK(!custodian_profile->IsManaged());
 
   base::string16 name = base::UTF8ToUTF16(
       profile_->GetPrefs()->GetString(prefs::kProfileName));
   int avatar_index = profile_->GetPrefs()->GetInteger(
       prefs::kProfileAvatarIndex);
   ManagedUserRegistrationInfo info(name, avatar_index);
   registration_utility->Register(
       managed_user_id,
       info,
@@ skipping 70 matching lines @@
 
 void ManagedUserService::OnBrowserSetLastActive(Browser* browser) {
   bool profile_became_active = profile_->IsSameProfile(browser->profile());
   if (!is_profile_active_ && profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_OpenProfile"));
   else if (is_profile_active_ && !profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_SwitchProfile"));
 
   is_profile_active_ = profile_became_active;
 }