[webui settings] send user profiles info earlier during load

chrome/browser/ui/webui/options2/browser_options_handler2.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/options2/browser_options_handler2.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 346 matching lines @@
           l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
 
 #if defined(OS_CHROMEOS)
   if (chromeos::UserManager::Get()->IsUserLoggedIn()) {
     values->SetString("username",
         chromeos::UserManager::Get()->GetLoggedInUser().email());
   }
 #endif
 
   // Pass along sync status early so it will be available during page init.
-  values->Set("syncData", GetSyncStateDictionary());
+  values->Set("syncData", GetSyncStateDictionary().release());
 
   values->SetString("privacyLearnMoreURL", chrome::kPrivacyLearnMoreURL);
 
   values->SetString(
       "languageSectionLabel",
       l10n_util::GetStringFUTF16(
           IDS_OPTIONS_ADVANCED_LANGUAGE_LABEL,
           l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME)));
 
 #if defined(OS_CHROMEOS)
   values->SetString("cloudPrintLearnMoreURL", chrome::kCloudPrintLearnMoreURL);
 
   // TODO(pastarmovj): replace this with a call to the CrosSettings list
   // handling functionality to come.
   values->Set("timezoneList",
       static_cast<chromeos::options2::SystemSettingsProvider*>(
           chromeos::CrosSettings::Get()->GetProvider(
               chromeos::kSystemTimezone))->GetTimezoneList());
 #endif
 #if defined(OS_MACOSX)
   values->SetString("macPasswordsWarning",
       l10n_util::GetStringUTF16(IDS_OPTIONS_PASSWORDS_MAC_WARNING));
   values->SetBoolean("multiple_profiles",
       g_browser_process->profile_manager()->GetNumberOfProfiles() > 1);
 #endif
+
+  if (multiprofile_)
+    values->Set("profilesInfo", GetProfilesInfoList().release());
 }
 
 void BrowserOptionsHandler::RegisterCloudPrintValues(DictionaryValue* values) {
 #if defined(OS_CHROMEOS)
   values->SetString("cloudPrintChromeosOptionLabel",
       l10n_util::GetStringFUTF16(
       IDS_CLOUD_PRINT_CHROMEOS_OPTION_LABEL,
       l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT)));
   values->SetString("cloudPrintChromeosOptionButton",
       l10n_util::GetStringFUTF16(
@@ skipping 120 matching lines @@
       base::Bind(&BrowserOptionsHandler::ScreenMagnifierChangeCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "virtualKeyboardChange",
       base::Bind(&BrowserOptionsHandler::VirtualKeyboardChangeCallback,
                  base::Unretained(this)));
 #endif
 }
 
 void BrowserOptionsHandler::OnStateChanged() {
-  scoped_ptr<DictionaryValue> value(GetSyncStateDictionary());
-  web_ui()->CallJavascriptFunction("BrowserOptions.updateSyncState", *value);
+  web_ui()->CallJavascriptFunction("BrowserOptions.updateSyncState",
+                                   *GetSyncStateDictionary());
 
   SendProfilesInfo();
 }
 
 void BrowserOptionsHandler::InitializeHandler() {
   Profile* profile = Profile::FromWebUI(web_ui());
   PrefService* prefs = profile->GetPrefs();
 
   ProfileSyncService* sync_service(
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile));
@@ skipping 57 matching lines @@
 #if !defined(OS_CHROMEOS)
   proxy_prefs_.reset(
       PrefSetObserver::CreateProxyPrefSetObserver(prefs, this));
 #endif  // !defined(OS_CHROMEOS)
 }
 
 void BrowserOptionsHandler::InitializePage() {
   OnTemplateURLServiceChanged();
   ObserveThemeChanged();
 
-  if (multiprofile_)
-    SendProfilesInfo();
-
   SetupMetricsReportingCheckbox();
   SetupMetricsReportingSettingVisibility();
   SetupFontSizeSelector();
   SetupPageZoomSelector();
   SetupAutoOpenFileTypes();
   SetupProxySettingsSection();
   SetupSSLConfigSettings();
 #if !defined(OS_CHROMEOS)
   if (cloud_print_connector_ui_enabled_) {
     SetupCloudPrintConnectorSection();
@@ skipping 271 matching lines @@
 
 void BrowserOptionsHandler::GetInstantFieldTrialStatus(const ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   base::FundamentalValue enabled(
       InstantFieldTrial::IsInstantExperiment(profile) &&
       !InstantFieldTrial::IsHiddenExperiment(profile));
   web_ui()->CallJavascriptFunction("BrowserOptions.setInstantFieldTrialStatus",
                                    enabled);
 }
 
-void BrowserOptionsHandler::SendProfilesInfo() {
-  // Set profile creation text and button if multi-profiles switch is on.
-  scoped_ptr<Value> visible(Value::CreateBooleanValue(multiprofile_));
-  web_ui()->CallJavascriptFunction("BrowserOptions.setProfilesSectionVisible",
-                                   *visible);
-
-  if (!multiprofile_)
-    return;
-
+scoped_ptr<ListValue> BrowserOptionsHandler::GetProfilesInfoList() {
   ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
-  ListValue profile_info_list;
+  scoped_ptr<ListValue> profile_info_list(new ListValue);
   FilePath current_profile_path =
       web_ui()->GetWebContents()->GetBrowserContext()->GetPath();
+
   for (size_t i = 0, e = cache.GetNumberOfProfiles(); i < e; ++i) {
     DictionaryValue* profile_value = new DictionaryValue();
     FilePath profile_path = cache.GetPathOfProfileAtIndex(i);
     profile_value->SetString("name", cache.GetNameOfProfileAtIndex(i));
     profile_value->Set("filePath", base::CreateFilePathValue(profile_path));
     profile_value->SetBoolean("isCurrentProfile",
                               profile_path == current_profile_path);
 
     bool is_gaia_picture =
         cache.IsUsingGAIAPictureOfProfileAtIndex(i) &&
         cache.GetGAIAPictureOfProfileAtIndex(i);
     if (is_gaia_picture) {
       gfx::Image icon = profiles::GetAvatarIconForWebUI(
           cache.GetAvatarIconOfProfileAtIndex(i), true);
       profile_value->SetString("iconURL",
           web_ui_util::GetImageDataUrl(*icon.ToSkBitmap()));
     } else {
       size_t icon_index = cache.GetAvatarIconIndexOfProfileAtIndex(i);
       profile_value->SetString("iconURL",
                                cache.GetDefaultAvatarIconUrl(icon_index));
     }
 
-    profile_info_list.Append(profile_value);
+    profile_info_list->Append(profile_value);
   }
 
+  return profile_info_list.Pass();
+}
+
+void BrowserOptionsHandler::SendProfilesInfo() {
   web_ui()->CallJavascriptFunction("BrowserOptions.setProfilesInfo",
-                                   profile_info_list);
+                                   *GetProfilesInfoList());
 }
 
 void BrowserOptionsHandler::CreateProfile(const ListValue* args) {
   // This handler could have been called in managed mode, for example because
   // the user fiddled with the web inspector. Silently return in this case.
   if (!ProfileManager::IsMultipleProfilesEnabled())
     return;
   ProfileManager::CreateMultiProfileAsync();
 }
 
@@ skipping 35 matching lines @@
   std::string email = chromeos::UserManager::Get()->GetLoggedInUser().email();
   if (!email.empty()) {
     web_ui()->CallJavascriptFunction("BrowserOptions.updateAccountPicture");
     base::StringValue email_value(email);
     web_ui()->CallJavascriptFunction("BrowserOptions.updateAccountPicture",
                                      email_value);
   }
 }
 #endif
 
-DictionaryValue* BrowserOptionsHandler::GetSyncStateDictionary() {
-  DictionaryValue* sync_status = new DictionaryValue;
+scoped_ptr<DictionaryValue> BrowserOptionsHandler::GetSyncStateDictionary() {
+  scoped_ptr<DictionaryValue> sync_status(new DictionaryValue);
   ProfileSyncService* service(ProfileSyncServiceFactory::
       GetInstance()->GetForProfile(Profile::FromWebUI(web_ui())));
   sync_status->SetBoolean("syncSystemEnabled", !!service);
   if (!service)
-    return sync_status;
+    return sync_status.Pass();
 
   sync_status->SetBoolean("setupCompleted",
                           service->HasSyncSetupCompleted());
   sync_status->SetBoolean("setupInProgress", service->FirstSetupInProgress());
 
   string16 status_label;
   string16 link_label;
   SigninManager* signin = SigninManagerFactory::GetForProfile(
       Profile::FromWebUI(web_ui()));
 
   bool status_has_error = sync_ui_util::GetStatusLabels(
       service, *signin, sync_ui_util::WITH_HTML, &status_label, &link_label) ==
           sync_ui_util::SYNC_ERROR;
   sync_status->SetString("statusText", status_label);
   sync_status->SetString("actionLinkText", link_label);
   sync_status->SetBoolean("hasError", status_has_error);
 
   sync_status->SetBoolean("managed", service->IsManaged());
   sync_status->SetBoolean("hasUnrecoverableError",
                           service->unrecoverable_error_detected());
   sync_status->SetBoolean("autoLoginVisible",
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableAutologin) &&
       service->AreCredentialsAvailable());
 
-  return sync_status;
+  return sync_status.Pass();
 }
 
 void BrowserOptionsHandler::HandleSelectDownloadLocation(
     const ListValue* args) {
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   select_folder_dialog_ = SelectFileDialog::Create(this);
   select_folder_dialog_->SelectFile(
       SelectFileDialog::SELECT_FOLDER,
       l10n_util::GetStringUTF16(IDS_OPTIONS_DOWNLOADLOCATION_BROWSE_TITLE),
       pref_service->GetFilePath(prefs::kDownloadDefaultDirectory),
@@ skipping 370 matching lines @@
 }
 
 void BrowserOptionsHandler::SetupSSLConfigSettings() {
   base::FundamentalValue checked(rev_checking_enabled_.GetValue());
   base::FundamentalValue disabled(rev_checking_enabled_.IsManaged());
   web_ui()->CallJavascriptFunction(
       "BrowserOptions.setCheckRevocationCheckboxState", checked, disabled);
 }
 
 }  // namespace options2