Clean up managed user settings dialogs.

chrome/browser/ui/webui/options/managed_user_settings_handler.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/ui/webui/options/managed_user_settings_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 80 matching lines @@
 
 namespace options {
 
 ManagedUserSettingsHandler::ManagedUserSettingsHandler()
     : has_seen_settings_dialog_(false) {
 }
 
 ManagedUserSettingsHandler::~ManagedUserSettingsHandler() {
 }
 
-void ManagedUserSettingsHandler::InitializeHandler() {
-  pref_change_registrar_.Init(Profile::FromWebUI(web_ui())->GetPrefs());
-  pref_change_registrar_.Add(
-      prefs::kManagedModeLocalPassphrase,
-      base::Bind(&ManagedUserSettingsHandler::OnLocalPassphraseChanged,
-                 base::Unretained(this)));
-}
-
 void ManagedUserSettingsHandler::InitializePage() {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableManagedUsers)) {
     return;
   }
 
-#if !defined(OS_CHROMEOS)
-  PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
-  bool passphrase_empty =
-      pref_service->GetString(prefs::kManagedModeLocalPassphrase).empty();
-  base::FundamentalValue is_passphrase_set(!passphrase_empty);
-  web_ui()->CallJavascriptFunction(
-      "ManagedUserSettings.passphraseChanged",
-      is_passphrase_set);
-#endif
-
   // Populate the list.
   UpdateViewFromModel();
 }
 
 void ManagedUserSettingsHandler::HandlePageOpened(const base::ListValue* args) {
   start_time_ = base::TimeTicks::Now();
   content::RecordAction(UserMetricsAction("ManagedMode_OpenSettings"));
   ManagedUserService* service = ManagedUserServiceFactory::GetForProfile(
       Profile::FromWebUI(web_ui()));
   ManagedModeNavigationObserver* observer =
       ManagedModeNavigationObserver::FromWebContents(
           web_ui()->GetWebContents());
 
   // Check if we need to give initial elevation for startup of a new profile.
   if (service->startup_elevation()) {
     service->set_startup_elevation(false);
 #if !defined(OS_CHROMEOS)
     observer->set_elevated(true);
 #endif
   } else {
     has_seen_settings_dialog_ = true;
   }
 
   if (observer->is_elevated()) {
-    web_ui()->CallJavascriptFunction("ManagedUserSettings.isAuthenticated",
+    web_ui()->CallJavascriptFunction("ManagedUserSettings.setAuthenticated",
                                      base::FundamentalValue(true));
   }
 }
 
 void ManagedUserSettingsHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static OptionsStringResource resources[] = {
     // Unlock the settings page to allow editing.
@@ skipping 13 matching lines @@
     { "getContentPacks", IDS_GET_CONTENT_PACKS_BUTTON },
     { "getContentPacksURL", IDS_GET_CONTENT_PACKS_URL },
     // Content pack restriction options.
     { "contentPackSettings", IDS_CONTENT_PACK_SETTINGS_LABEL },
     { "outsideContentPacksAllow", IDS_OUTSIDE_CONTENT_PACKS_ALLOW_RADIO },
     { "outsideContentPacksWarn", IDS_OUTSIDE_CONTENT_PACKS_WARN_RADIO },
     { "outsideContentPacksBlock", IDS_OUTSIDE_CONTENT_PACKS_BLOCK_RADIO },
     // Other managed user settings
     { "advancedManagedUserSettings", IDS_ADVANCED_MANAGED_USER_LABEL },
     { "enableSafeSearch", IDS_SAFE_SEARCH_ENABLED },
-    { "allowSignIn", IDS_SIGNIN_SYNC_ALLOWED },
-    { "disableHistoryDeletion", IDS_HISTORY_DELETION_DISABLED },
-    { "usePassphrase", IDS_USE_PASSPHRASE_LABEL },
-    { "setPassphrase", IDS_SET_PASSPHRASE_BUTTON }
+    { "setPassphrase", IDS_SET_PASSPHRASE_BUTTON },
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(localized_strings, "managedUserSettingsPage",
                 IDS_MANAGED_USER_SETTINGS_TITLE);
   RegisterTitle(localized_strings, "manualExceptions",
                 IDS_MANUAL_EXCEPTION_HEADER);
   localized_strings->SetBoolean(
       "managedUsersEnabled",
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableManagedUsers));
 }
 
 void ManagedUserSettingsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "confirmManagedUserSettings",
       base::Bind(&ManagedUserSettingsHandler::SaveMetrics,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "settingsPageOpened",
       base::Bind(&ManagedUserSettingsHandler::HandlePageOpened,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("removeManualException",
+  web_ui()->RegisterMessageCallback(
+      "removeManualException",
       base::Bind(&ManagedUserSettingsHandler::RemoveManualException,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("setManualException",
+  web_ui()->RegisterMessageCallback(
+      "setManualException",
       base::Bind(&ManagedUserSettingsHandler::SetManualException,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("checkManualExceptionValidity",
-      base::Bind(
-      &ManagedUserSettingsHandler::CheckManualExceptionValidity,
+  web_ui()->RegisterMessageCallback(
+      "checkManualExceptionValidity",
+      base::Bind(&ManagedUserSettingsHandler::CheckManualExceptionValidity,
                  base::Unretained(this)));
 }
 
 void ManagedUserSettingsHandler::SaveMetrics(const ListValue* args) {
   if (!has_seen_settings_dialog_) {
     has_seen_settings_dialog_ = true;
     UMA_HISTOGRAM_LONG_TIMES("ManagedMode.UserSettingsFirstRunTime",
                              base::TimeTicks::Now() - start_time_);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("ManagedMode.UserSettingsModifyTime",
                              base::TimeTicks::Now() - start_time_);
   }
 }
 
-void ManagedUserSettingsHandler::OnLocalPassphraseChanged() {
-  PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
-  base::FundamentalValue is_passphrase_set(!pref_service->GetString(
-      prefs::kManagedModeLocalPassphrase).empty());
-  web_ui()->CallJavascriptFunction("ManagedUserSettings.passphraseChanged",
-                                   is_passphrase_set);
-}
-
 void ManagedUserSettingsHandler::RemoveManualException(
     const ListValue* args) {
   // Check if the user is authenticated.
   if (!ManagedModeNavigationObserver::FromWebContents(
       web_ui()->GetWebContents())->is_elevated())
     return;
 
   size_t arg_i = 0;
   std::string pattern;
   CHECK(args->GetString(arg_i++, &pattern));
@@ skipping 73 matching lines @@
 void ManagedUserSettingsHandler::UpdateViewFromModel() {
   ListValue entries;
   AddCurrentURLEntries(web_ui(), &entries);
 
   web_ui()->CallJavascriptFunction(
       "ManagedUserSettings.setManualExceptions",
       entries);
 }
 
 }  // namespace options