Settings People Rewrite: Make Sync/Sign-in naming consistent to People.

chrome/browser/ui/webui/settings/people_handler.cc

 // Copyright 2015 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/settings/sync_handler.h"
+#include "chrome/browser/ui/webui/settings/people_handler.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
@@ skipping 56 matching lines @@
   bool sync_nothing;
   syncer::ModelTypeSet data_types;
   std::string passphrase;
   bool passphrase_is_gaia;
 };
 
 SyncConfigInfo::SyncConfigInfo()
     : encrypt_all(false),
       sync_everything(false),
       sync_nothing(false),
-      passphrase_is_gaia(false) {
-}
+      passphrase_is_gaia(false) {}
 
 SyncConfigInfo::~SyncConfigInfo() {}
 
 bool GetConfiguration(const std::string& json, SyncConfigInfo* config) {
   scoped_ptr<base::Value> parsed_value = base::JSONReader::Read(json);
   base::DictionaryValue* result;
   if (!parsed_value || !parsed_value->GetAsDictionary(&result)) {
     DLOG(ERROR) << "GetConfiguration() not passed a Dictionary";
     return false;
   }
@@ skipping 49 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 }  // namespace
 
 namespace settings {
 
-SyncHandler::SyncHandler(Profile* profile)
+PeopleHandler::PeopleHandler(Profile* profile)
     : profile_(profile),
       configuring_sync_(false),
       sync_service_observer_(this) {
   PrefService* prefs = profile_->GetPrefs();
   profile_pref_registrar_.Init(prefs);
   profile_pref_registrar_.Add(
-      prefs::kSigninAllowed, base::Bind(&SyncHandler::OnSigninAllowedPrefChange,
-                                        base::Unretained(this)));
+      prefs::kSigninAllowed,
+      base::Bind(&PeopleHandler::OnSigninAllowedPrefChange,
+                 base::Unretained(this)));
 
   ProfileSyncService* sync_service(
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_));
   if (sync_service)
     sync_service_observer_.Add(sync_service);
 }
 
-SyncHandler::~SyncHandler() {
+PeopleHandler::~PeopleHandler() {
   // Just exit if running unit tests (no actual WebUI is attached).
   if (!web_ui())
     return;
 
   // This case is hit when the user performs a back navigation.
   CloseSyncSetup();
 }
 
-void SyncHandler::ConfigureSyncDone() {
+void PeopleHandler::ConfigureSyncDone() {
   base::StringValue page("done");
   web_ui()->CallJavascriptFunction("settings.SyncPrivateApi.showSyncSetupPage",
                                    page);
 
   // Suppress the sign in promo once the user starts sync. This way the user
   // doesn't see the sign in promo even if they sign out later on.
   signin::SetUserSkippedPromo(profile_);
 
   ProfileSyncService* service = GetSyncService();
   DCHECK(service);
   if (!service->HasSyncSetupCompleted()) {
     // This is the first time configuring sync, so log it.
     base::FilePath profile_file_path = profile_->GetPath();
     ProfileMetrics::LogProfileSyncSignIn(profile_file_path);
 
     // We're done configuring, so notify ProfileSyncService that it is OK to
     // start syncing.
     service->SetSetupInProgress(false);
     service->SetSyncSetupCompleted();
   }
 }
 
-bool SyncHandler::IsActiveLogin() const {
+bool PeopleHandler::IsActiveLogin() const {
   // LoginUIService can be nullptr if page is brought up in incognito mode
   // (i.e. if the user is running in guest mode in cros and brings up settings).
   LoginUIService* service = GetLoginUIService();
   return service && (service->current_login_ui() == this);
 }
 
-void SyncHandler::RegisterMessages() {
+void PeopleHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "SyncSetupDidClosePage",
-      base::Bind(&SyncHandler::OnDidClosePage,
-                 base::Unretained(this)));
+      base::Bind(&PeopleHandler::OnDidClosePage, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupConfigure",
-      base::Bind(&SyncHandler::HandleConfigure,
-                 base::Unretained(this)));
+      base::Bind(&PeopleHandler::HandleConfigure, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupShowSetupUI",
-      base::Bind(&SyncHandler::HandleShowSetupUI,
-                 base::Unretained(this)));
+      base::Bind(&PeopleHandler::HandleShowSetupUI, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupCloseTimeout",
-      base::Bind(&SyncHandler::HandleCloseTimeout, base::Unretained(this)));
+      base::Bind(&PeopleHandler::HandleCloseTimeout, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupGetSyncStatus",
-      base::Bind(&SyncHandler::HandleGetSyncStatus, base::Unretained(this)));
+      base::Bind(&PeopleHandler::HandleGetSyncStatus, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupManageOtherPeople",
-      base::Bind(&SyncHandler::HandleManageOtherPeople,
+      base::Bind(&PeopleHandler::HandleManageOtherPeople,
                  base::Unretained(this)));
 #if defined(OS_CHROMEOS)
   web_ui()->RegisterMessageCallback(
       "SyncSetupDoSignOutOnAuthError",
-      base::Bind(&SyncHandler::HandleDoSignOutOnAuthError,
+      base::Bind(&PeopleHandler::HandleDoSignOutOnAuthError,
                  base::Unretained(this)));
 #else
-  web_ui()->RegisterMessageCallback("SyncSetupStopSyncing",
-      base::Bind(&SyncHandler::HandleStopSyncing,
-                 base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("SyncSetupStartSignIn",
-      base::Bind(&SyncHandler::HandleStartSignin,
-                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "SyncSetupStopSyncing",
+      base::Bind(&PeopleHandler::HandleStopSyncing, base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "SyncSetupStartSignIn",
+      base::Bind(&PeopleHandler::HandleStartSignin, base::Unretained(this)));
 #endif
 }
 
 #if !defined(OS_CHROMEOS)
-void SyncHandler::DisplayGaiaLogin(signin_metrics::AccessPoint access_point) {
+void PeopleHandler::DisplayGaiaLogin(signin_metrics::AccessPoint access_point) {
   DCHECK(!sync_startup_tracker_);
   // Advanced options are no longer being configured if the login screen is
   // visible. If the user exits the signin wizard after this without
   // configuring sync, CloseSyncSetup() will ensure they are logged out.
   configuring_sync_ = false;
   DisplayGaiaLoginInNewTabOrWindow(access_point);
 }
 
-void SyncHandler::DisplayGaiaLoginInNewTabOrWindow(
+void PeopleHandler::DisplayGaiaLoginInNewTabOrWindow(
     signin_metrics::AccessPoint access_point) {
-  Browser* browser = chrome::FindBrowserWithWebContents(
-      web_ui()->GetWebContents());
+  Browser* browser =
+      chrome::FindBrowserWithWebContents(web_ui()->GetWebContents());
   bool force_new_tab = false;
   if (!browser) {
     // Settings is not displayed in a browser window. Open a new window.
     browser = new Browser(Browser::CreateParams(Browser::TYPE_TABBED, profile_,
                                                 chrome::GetActiveDesktop()));
     force_new_tab = true;
   }
 
   // If the signin manager already has an authenticated username, this is a
   // re-auth scenario, and we need to ensure that the user signs in with the
   // same email address.
   GURL url;
-  if (SigninManagerFactory::GetForProfile(
-      browser->profile())->IsAuthenticated()) {
+  if (SigninManagerFactory::GetForProfile(browser->profile())
+          ->IsAuthenticated()) {

[dschuyler, 2015/12/10 00:51:48]

I think cl format is making a mistake here.  Please change this back.  :)

[tommycli, 2015/12/10 01:57:02]

Done. I provided a third alternative, since I think the old one is pretty
egregiously bad actually.

     UMA_HISTOGRAM_ENUMERATION("Signin.Reauth",
                               signin_metrics::HISTOGRAM_REAUTH_SHOWN,
                               signin_metrics::HISTOGRAM_REAUTH_MAX);
 
     SigninErrorController* error_controller =
         SigninErrorControllerFactory::GetForProfile(browser->profile());
     DCHECK(error_controller->HasError());
     if (!force_new_tab) {
       browser->window()->ShowAvatarBubbleFromAvatarButton(
           BrowserWindow::AVATAR_BUBBLE_MODE_REAUTH,
@@ skipping 13 matching lines @@
           access_point, signin_metrics::Reason::REASON_SIGNIN_PRIMARY_ACCOUNT,
           true);
     }
   }
 
   if (url.is_valid())
     chrome::ShowSingletonTab(browser, url);
 }
 #endif
 
-bool SyncHandler::PrepareSyncSetup() {
+bool PeopleHandler::PrepareSyncSetup() {
   // If the wizard is already visible, just focus that one.
   if (FocusExistingWizardIfPresent()) {
     if (!IsActiveLogin())
       CloseSyncSetup();
     return false;
   }
 
   // Notify services that login UI is now active.
   GetLoginUIService()->SetLoginUI(this);
 
   ProfileSyncService* service = GetSyncService();
   if (service)
     service->SetSetupInProgress(true);
 
   return true;
 }
 
-void SyncHandler::DisplaySpinner() {
+void PeopleHandler::DisplaySpinner() {
   configuring_sync_ = true;
   base::StringValue page("spinner");
   base::DictionaryValue args;
 
   const int kTimeoutSec = 30;
   DCHECK(!backend_start_timer_);
   backend_start_timer_.reset(new base::OneShotTimer());
   backend_start_timer_->Start(FROM_HERE,
-                              base::TimeDelta::FromSeconds(kTimeoutSec),
-                              this, &SyncHandler::DisplayTimeout);
+                              base::TimeDelta::FromSeconds(kTimeoutSec), this,
+                              &PeopleHandler::DisplayTimeout);
 
   web_ui()->CallJavascriptFunction("settings.SyncPrivateApi.showSyncSetupPage",
                                    page, args);
 }
 
 // TODO(kochi): Handle error conditions other than timeout.
 // http://crbug.com/128692
-void SyncHandler::DisplayTimeout() {
+void PeopleHandler::DisplayTimeout() {
   // Stop a timer to handle timeout in waiting for checking network connection.
   backend_start_timer_.reset();
 
   // Do not listen to sync startup events.
   sync_startup_tracker_.reset();
 
   base::StringValue page("timeout");
   base::DictionaryValue args;
   web_ui()->CallJavascriptFunction("settings.SyncPrivateApi.showSyncSetupPage",
                                    page, args);
 }
 
-void SyncHandler::OnDidClosePage(const base::ListValue* args) {
+void PeopleHandler::OnDidClosePage(const base::ListValue* args) {
   CloseSyncSetup();
 }
 
-void SyncHandler::SyncStartupFailed() {
+void PeopleHandler::SyncStartupFailed() {
   // Stop a timer to handle timeout in waiting for checking network connection.
   backend_start_timer_.reset();
 
   // Just close the sync overlay (the idea is that the base settings page will
   // display the current error.)
   CloseUI();
 }
 
-void SyncHandler::SyncStartupCompleted() {
+void PeopleHandler::SyncStartupCompleted() {
   ProfileSyncService* service = GetSyncService();
   DCHECK(service->IsBackendInitialized());
 
   // Stop a timer to handle timeout in waiting for checking network connection.
   backend_start_timer_.reset();
 
   DisplayConfigureSync(false);
 }
 
-ProfileSyncService* SyncHandler::GetSyncService() const {
+ProfileSyncService* PeopleHandler::GetSyncService() const {
   return profile_->IsSyncAllowed()
              ? ProfileSyncServiceFactory::GetForProfile(profile_)
              : nullptr;
 }
 
-void SyncHandler::HandleConfigure(const base::ListValue* args) {
+void PeopleHandler::HandleConfigure(const base::ListValue* args) {
   DCHECK(!sync_startup_tracker_);
   std::string json;
   if (!args->GetString(0, &json)) {
     NOTREACHED() << "Could not read JSON argument";
     return;
   }
   if (json.empty()) {
     NOTREACHED();
     return;
   }
@@ skipping 102 matching lines @@
 
   ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_CUSTOMIZE);
   if (configuration.encrypt_all)
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_ENCRYPT);
   if (configuration.passphrase_is_gaia && !configuration.passphrase.empty())
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_PASSPHRASE);
   if (!configuration.sync_everything)
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_CHOOSE);
 }
 
-void SyncHandler::HandleShowSetupUI(const base::ListValue* args) {
+void PeopleHandler::HandleShowSetupUI(const base::ListValue* args) {
   if (!GetSyncService()) {
     CloseUI();
     return;
   }
 
   SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile_);
   if (!signin->IsAuthenticated()) {
     // For web-based signin, the signin page is not displayed in an overlay
     // on the settings page. So if we get here, it must be due to the user
     // cancelling signin (by reloading the sync settings page during initial
@@ skipping 14 matching lines @@
 
   // If a setup wizard is present on this page or another, bring it to focus.
   // Otherwise, display a new one on this page.
   if (!FocusExistingWizardIfPresent())
     OpenSyncSetup(args);
 }
 
 #if defined(OS_CHROMEOS)
 // On ChromeOS, we need to sign out the user session to fix an auth error, so
 // the user goes through the real signin flow to generate a new auth token.
-void SyncHandler::HandleDoSignOutOnAuthError(const base::ListValue* args) {
+void PeopleHandler::HandleDoSignOutOnAuthError(const base::ListValue* args) {
   DVLOG(1) << "Signing out the user to fix a sync error.";
   chrome::AttemptUserExit();
 }
 #endif
 
 #if !defined(OS_CHROMEOS)
-void SyncHandler::HandleStartSignin(const base::ListValue* args) {
+void PeopleHandler::HandleStartSignin(const base::ListValue* args) {
   // Should only be called if the user is not already signed in.
   DCHECK(!SigninManagerFactory::GetForProfile(profile_)->IsAuthenticated());
   OpenSyncSetup(args);
 }
 
-void SyncHandler::HandleStopSyncing(const base::ListValue* args) {
+void PeopleHandler::HandleStopSyncing(const base::ListValue* args) {
   if (GetSyncService())
     ProfileSyncService::SyncEvent(ProfileSyncService::STOP_FROM_OPTIONS);
   SigninManagerFactory::GetForProfile(profile_)
       ->SignOut(signin_metrics::USER_CLICKED_SIGNOUT_SETTINGS);
 
   bool delete_profile = false;
   if (args->GetBoolean(0, &delete_profile) && delete_profile) {
     // Do as BrowserOptionsHandler::DeleteProfile().
     options::helper::DeleteProfileAtPath(profile_->GetPath(), web_ui());
   }
 }
 #endif
 
-void SyncHandler::HandleCloseTimeout(const base::ListValue* args) {
+void PeopleHandler::HandleCloseTimeout(const base::ListValue* args) {
   CloseSyncSetup();
 }
 
-void SyncHandler::HandleGetSyncStatus(const base::ListValue* /* args */) {
+void PeopleHandler::HandleGetSyncStatus(const base::ListValue* /* args */) {
   UpdateSyncState();
 }
 
-void SyncHandler::HandleManageOtherPeople(const base::ListValue* /* args */) {
+void PeopleHandler::HandleManageOtherPeople(const base::ListValue* /* args */) {
   UserManager::Show(base::FilePath(), profiles::USER_MANAGER_NO_TUTORIAL,
                     profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
 }
 
-void SyncHandler::CloseSyncSetup() {
+void PeopleHandler::CloseSyncSetup() {
   // Stop a timer to handle timeout in waiting for checking network connection.
   backend_start_timer_.reset();
 
   // Clear the sync startup tracker, since the setup wizard is being closed.
   sync_startup_tracker_.reset();
 
   ProfileSyncService* sync_service = GetSyncService();
   if (IsActiveLogin()) {
     // Don't log a cancel event if the sync setup dialog is being
     // automatically closed due to an auth error.
     if (!sync_service || (!sync_service->HasSyncSetupCompleted() &&
-        sync_service->GetAuthError().state() == GoogleServiceAuthError::NONE)) {
+                          sync_service->GetAuthError().state() ==
+                              GoogleServiceAuthError::NONE)) {
       if (configuring_sync_) {
         ProfileSyncService::SyncEvent(
             ProfileSyncService::CANCEL_DURING_CONFIGURE);
 
         // If the user clicked "Cancel" while setting up sync, disable sync
         // because we don't want the sync backend to remain in the
         // first-setup-incomplete state.
         // Note: In order to disable sync across restarts on Chrome OS,
         // we must call RequestStop(CLEAR_DATA), which suppresses sync startup
         // in addition to disabling it.
         if (sync_service) {
           DVLOG(1) << "Sync setup aborted by user action";
           sync_service->RequestStop(ProfileSyncService::CLEAR_DATA);
-  #if !defined(OS_CHROMEOS)
+#if !defined(OS_CHROMEOS)
           // Sign out the user on desktop Chrome if they click cancel during
           // initial setup.
           // TODO(rsimha): Revisit this for M30. See http://crbug.com/252049.
           if (sync_service->IsFirstSetupInProgress()) {
             SigninManagerFactory::GetForProfile(profile_)
                 ->SignOut(signin_metrics::ABORT_SIGNIN);
           }
-  #endif
+#endif
         }
       }
     }
 
     GetLoginUIService()->LoginUIClosed(this);
   }
 
   // Alert the sync service anytime the sync setup dialog is closed. This can
   // happen due to the user clicking the OK or Cancel button, or due to the
   // dialog being closed by virtue of sync being disabled in the background.
   if (sync_service)
     sync_service->SetSetupInProgress(false);
 
   configuring_sync_ = false;
 }
 
-void SyncHandler::OpenSyncSetup(const base::ListValue* args) {
+void PeopleHandler::OpenSyncSetup(const base::ListValue* args) {
   if (!PrepareSyncSetup())
     return;
 
   // There are several different UI flows that can bring the user here:
   // 1) Signin promo.
   // 2) Normal signin through settings page (IsAuthenticated() is false).
   // 3) Previously working credentials have expired.
   // 4) User is signed in, but has stopped sync via the google dashboard, and
   //    signout is prohibited by policy so we need to force a re-auth.
   // 5) User clicks [Advanced Settings] button on options page while already
@@ skipping 29 matching lines @@
     CloseUI();
     return;
   }
 
   // User is already logged in. They must have brought up the config wizard
   // via the "Advanced..." button or through One-Click signin (cases 4-6), or
   // they are re-enabling sync after having disabled it (case 7).
   DisplayConfigureSync(false);
 }
 
-void SyncHandler::OpenConfigureSync() {
+void PeopleHandler::OpenConfigureSync() {
   if (!PrepareSyncSetup())
     return;
 
   DisplayConfigureSync(false);
 }
 
-void SyncHandler::FocusUI() {
+void PeopleHandler::FocusUI() {
   DCHECK(IsActiveLogin());
   WebContents* web_contents = web_ui()->GetWebContents();
   web_contents->GetDelegate()->ActivateContents(web_contents);
 }
 
-void SyncHandler::CloseUI() {
+void PeopleHandler::CloseUI() {
   CloseSyncSetup();
   base::StringValue page("done");
   web_ui()->CallJavascriptFunction("settings.SyncPrivateApi.showSyncSetupPage",
                                    page);
 }
 
-void SyncHandler::GoogleSigninSucceeded(const std::string& /* account_id */,
-                                        const std::string& /* username */,
-                                        const std::string& /* password */) {
+void PeopleHandler::GoogleSigninSucceeded(const std::string& /* account_id */,
+                                          const std::string& /* username */,
+                                          const std::string& /* password */) {
   UpdateSyncState();
 }
 
-void SyncHandler::GoogleSignedOut(const std::string& /* account_id */,
-                                  const std::string& /* username */) {
+void PeopleHandler::GoogleSignedOut(const std::string& /* account_id */,
+                                    const std::string& /* username */) {
   UpdateSyncState();
 }
 
-void SyncHandler::OnStateChanged() {
+void PeopleHandler::OnStateChanged() {
   UpdateSyncState();
 }
 
-scoped_ptr<base::DictionaryValue> SyncHandler::GetSyncStateDictionary() {
+scoped_ptr<base::DictionaryValue> PeopleHandler::GetSyncStateDictionary() {
   // The items which are to be written into |sync_status| are also described in
   // chrome/browser/resources/options/browser_options.js in @typedef
   // for SyncStatus. Please update it whenever you add or remove any keys here.
   scoped_ptr<base::DictionaryValue> sync_status(new base::DictionaryValue);
   if (profile_->IsGuestSession()) {
     // Cannot display signin status when running in guest mode on chromeos
     // because there is no SigninManager.
     sync_status->SetBoolean("signinAllowed", false);
     return sync_status.Pass();
   }
@@ skipping 32 matching lines @@
   sync_status->SetBoolean("hasError", status_has_error);
 
   sync_status->SetBoolean("managed", service && service->IsManaged());
   sync_status->SetBoolean("signedIn", signin->IsAuthenticated());
   sync_status->SetBoolean("hasUnrecoverableError",
                           service && service->HasUnrecoverableError());
 
   return sync_status.Pass();
 }
 
-bool SyncHandler::IsExistingWizardPresent() {
+bool PeopleHandler::IsExistingWizardPresent() {
   LoginUIService* service = GetLoginUIService();
   DCHECK(service);
   return service->current_login_ui() != nullptr;
 }
 
-bool SyncHandler::FocusExistingWizardIfPresent() {
+bool PeopleHandler::FocusExistingWizardIfPresent() {
   if (!IsExistingWizardPresent())
     return false;
 
   LoginUIService* service = GetLoginUIService();
   DCHECK(service);
   service->current_login_ui()->FocusUI();
   return true;
 }
 
-void SyncHandler::DisplayConfigureSync(bool passphrase_failed) {
+void PeopleHandler::DisplayConfigureSync(bool passphrase_failed) {
   // Should never call this when we are not signed in.
   DCHECK(SigninManagerFactory::GetForProfile(profile_)->IsAuthenticated());
   ProfileSyncService* service = GetSyncService();
   DCHECK(service);
   if (!service->IsBackendInitialized()) {
     service->RequestStart();
 
     // See if it's even possible to bring up the sync backend - if not
     // (unrecoverable error?), don't bother displaying a spinner that will be
     // immediately closed because this leads to some ugly infinite UI loop (see
@@ skipping 58 matching lines @@
 
   // To distinguish between FROZEN_IMPLICIT_PASSPHRASE and CUSTOM_PASSPHRASE
   // we only set usePassphrase for CUSTOM_PASSPHRASE.
   args.SetBoolean("usePassphrase",
                   service->GetPassphraseType() == syncer::CUSTOM_PASSPHRASE);
   base::Time passphrase_time = service->GetExplicitPassphraseTime();
   syncer::PassphraseType passphrase_type = service->GetPassphraseType();
   if (!passphrase_time.is_null()) {
     base::string16 passphrase_time_str =
         base::TimeFormatShortDate(passphrase_time);
-    args.SetString(
-        "enterPassphraseBody",
-        GetStringFUTF16(IDS_SYNC_ENTER_PASSPHRASE_BODY_WITH_DATE,
-                        passphrase_time_str));
+    args.SetString("enterPassphraseBody",
+                   GetStringFUTF16(IDS_SYNC_ENTER_PASSPHRASE_BODY_WITH_DATE,
+                                   passphrase_time_str));
     args.SetString(
         "enterGooglePassphraseBody",
         GetStringFUTF16(IDS_SYNC_ENTER_GOOGLE_PASSPHRASE_BODY_WITH_DATE,
                         passphrase_time_str));
     switch (passphrase_type) {
       case syncer::FROZEN_IMPLICIT_PASSPHRASE:
         args.SetString(
             "fullEncryptionBody",
             GetStringFUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_GOOGLE_WITH_DATE,
                             passphrase_time_str));
         break;
       case syncer::CUSTOM_PASSPHRASE:
         args.SetString(
             "fullEncryptionBody",
             GetStringFUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM_WITH_DATE,
                             passphrase_time_str));
         break;
       default:
-        args.SetString(
-            "fullEncryptionBody",
-            GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
+        args.SetString("fullEncryptionBody",
+                       GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
         break;
     }
   } else if (passphrase_type == syncer::CUSTOM_PASSPHRASE) {
-    args.SetString(
-        "fullEncryptionBody",
-        GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
+    args.SetString("fullEncryptionBody",
+                   GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
   } else {
-    args.SetString(
-        "fullEncryptionBody",
-        GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_DATA));
+    args.SetString("fullEncryptionBody",
+                   GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_DATA));
   }
 
   base::StringValue page("configure");
   web_ui()->CallJavascriptFunction("settings.SyncPrivateApi.showSyncSetupPage",
                                    page, args);
 
   // Make sure the tab used for the Gaia sign in does not cover the settings
   // tab.
   FocusUI();
 }
 
-LoginUIService* SyncHandler::GetLoginUIService() const {
+LoginUIService* PeopleHandler::GetLoginUIService() const {
   return LoginUIServiceFactory::GetForProfile(profile_);
 }
 
-void SyncHandler::UpdateSyncState() {
+void PeopleHandler::UpdateSyncState() {
   web_ui()->CallJavascriptFunction("settings.SyncPrivateApi.sendSyncStatus",
                                    *GetSyncStateDictionary());
 }
 
-void SyncHandler::OnSigninAllowedPrefChange() {
+void PeopleHandler::OnSigninAllowedPrefChange() {
   UpdateSyncState();
 }
 
 }  // namespace settings