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 38 matching lines @@
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #endif
 
+#if defined(ENABLE_THEMES)
+#include "chrome/browser/themes/theme_service.h"
+#include "chrome/browser/themes/theme_service_factory.h"
+#endif
+
 using base::DictionaryValue;
 using base::UserMetricsAction;
 using content::BrowserThread;
 
 ManagedUserService::URLFilterContext::URLFilterContext()
     : ui_url_filter_(new ManagedModeURLFilter),
       io_url_filter_(new ManagedModeURLFilter) {}
 ManagedUserService::URLFilterContext::~URLFilterContext() {}
 
 ManagedModeURLFilter*
@@ skipping 49 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 188 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 84 matching lines @@
   // 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();
+#if defined(ENABLE_THEMES)
+  // 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();
+  }
+#endif
 
-  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);
-  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(!custodian_profile->IsManaged());
 
@@ skipping 78 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;
 }