Settings People Revamp: Update PeopleHandler to use JS lifecycle calls.

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/people_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 155 matching lines @@
 // static
 const char PeopleHandler::kSpinnerPageStatus[] = "spinner";
 const char PeopleHandler::kConfigurePageStatus[] = "configure";
 const char PeopleHandler::kTimeoutPageStatus[] = "timeout";
 const char PeopleHandler::kDonePageStatus[] = "done";
 const char PeopleHandler::kPassphraseFailedPageStatus[] = "passphraseFailed";
 
 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(&PeopleHandler::OnSigninAllowedPrefChange,
-                 base::Unretained(this)));
-
-  ProfileSyncService* sync_service(
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_));
-  if (sync_service)
-    sync_service_observer_.Add(sync_service);
-}
+      sync_service_observer_(this) {}
 
 PeopleHandler::~PeopleHandler() {
   // Early 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();
 }
 
@@ skipping 35 matching lines @@
 #else
   web_ui()->RegisterMessageCallback(
       "SyncSetupStopSyncing",
       base::Bind(&PeopleHandler::HandleStopSyncing, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupStartSignIn",
       base::Bind(&PeopleHandler::HandleStartSignin, base::Unretained(this)));
 #endif
 }
 
+void PeopleHandler::OnJavascriptAllowed() {
+  PrefService* prefs = profile_->GetPrefs();
+  profile_pref_registrar_.Init(prefs);
+  profile_pref_registrar_.Add(
+      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);
+}
+
+void PeopleHandler::OnJavascriptDisallowed() {
+  profile_pref_registrar_.RemoveAll();
+  sync_service_observer_.RemoveAll();
+}
+
 #if !defined(OS_CHROMEOS)
 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);
 }
 
@@ skipping 69 matching lines @@
 void PeopleHandler::DisplaySpinner() {
   configuring_sync_ = true;
 
   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,
                               &PeopleHandler::DisplayTimeout);
 
-  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
-                                   base::StringValue("page-status-changed"),
-                                   base::StringValue(kSpinnerPageStatus));
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("page-status-changed"),
+                         base::StringValue(kSpinnerPageStatus));
 }
 
 // TODO(kochi): Handle error conditions other than timeout.
 // http://crbug.com/128692
 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();
 
-  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
-                                   base::StringValue("page-status-changed"),
-                                   base::StringValue(kTimeoutPageStatus));
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("page-status-changed"),
+                         base::StringValue(kTimeoutPageStatus));
 }
 
 void PeopleHandler::OnDidClosePage(const base::ListValue* args) {
   CloseSyncSetup();
 }
 
 void PeopleHandler::SyncStartupFailed() {
   // Stop a timer to handle timeout in waiting for checking network connection.
   backend_start_timer_.reset();
 
@@ skipping 142 matching lines @@
                               base::StringValue(kConfigurePageStatus));
   }
 
   if (configuration.encrypt_all)
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_ENCRYPT);
   if (configuration.passphrase_is_gaia && !configuration.passphrase.empty())
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_PASSPHRASE);
 }
 
 void PeopleHandler::HandleShowSetupUI(const base::ListValue* args) {
+  AllowJavascript();
+
   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 178 matching lines @@
 }
 
 void PeopleHandler::FocusUI() {
   DCHECK(IsActiveLogin());
   WebContents* web_contents = web_ui()->GetWebContents();
   web_contents->GetDelegate()->ActivateContents(web_contents);
 }
 
 void PeopleHandler::CloseUI() {
   CloseSyncSetup();
-  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
-                                   base::StringValue("page-status-changed"),
-                                   base::StringValue(kDonePageStatus));
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("page-status-changed"),
+                         base::StringValue(kDonePageStatus));
 }
 
 void PeopleHandler::GoogleSigninSucceeded(const std::string& /* account_id */,
                                           const std::string& /* username */,
                                           const std::string& /* password */) {
   UpdateSyncStatus();
 }
 
 void PeopleHandler::GoogleSignedOut(const std::string& /* account_id */,
                                     const std::string& /* username */) {
@@ skipping 178 matching lines @@
         break;
     }
   } else if (passphrase_type == syncer::CUSTOM_PASSPHRASE) {
     args.SetString("fullEncryptionBody",
                    GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
   } else {
     args.SetString("fullEncryptionBody",
                    GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_DATA));
   }
 
-  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
-                                   base::StringValue("sync-prefs-changed"),
-                                   args);
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("sync-prefs-changed"), args);
 
   // Make sure the tab used for the Gaia sign in does not cover the settings
   // tab.
   FocusUI();
 }
 
 LoginUIService* PeopleHandler::GetLoginUIService() const {
   return LoginUIServiceFactory::GetForProfile(profile_);
 }
 
 void PeopleHandler::UpdateSyncStatus() {
-  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
-                                   base::StringValue("sync-status-changed"),
-                                   *GetSyncStatusDictionary());
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("sync-status-changed"),
+                         *GetSyncStatusDictionary());
 }
 
 void PeopleHandler::OnSigninAllowedPrefChange() {
   UpdateSyncStatus();
 }
 
 void PeopleHandler::MarkFirstSetupComplete() {
   // 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->IsFirstSetupComplete())
     return;
 
   // 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->SetFirstSetupComplete();
 }
 
 }  // namespace settings