Implemented argument wrapping for CallJS.

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.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/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 762 matching lines @@
               &SigninScreenHandler::HandleShowLoadingTimeoutError);
   AddCallback("updateOfflineLogin",
               &SigninScreenHandler::HandleUpdateOfflineLogin);
 }
 
 void SigninScreenHandler::HandleGetUsers() {
   SendUserList(false);
 }
 
 void SigninScreenHandler::ClearAndEnablePassword() {
-  base::FundamentalValue force_online(false);
-  CallJS("cr.ui.Oobe.resetSigninUI", force_online);
+  CallJS("cr.ui.Oobe.resetSigninUI", false);
 }
 
 void SigninScreenHandler::ClearUserPodPassword() {
   CallJS("cr.ui.Oobe.clearUserPodPassword");
 }
 
 void SigninScreenHandler::OnLoginSuccess(const std::string& username) {
-  base::StringValue username_value(username);
-  CallJS("cr.ui.Oobe.onLoginSuccess", username_value);
+  CallJS("cr.ui.Oobe.onLoginSuccess", username);
 }
 
 void SigninScreenHandler::OnUserRemoved(const std::string& username) {
   SendUserList(false);
 }
 
 void SigninScreenHandler::OnUserImageChanged(const User& user) {
-  if (!page_is_ready())
-    return;
-
-  base::StringValue user_email(user.email());
-  CallJS("login.AccountPickerScreen.updateUserImage", user_email);
+  if (page_is_ready())
+    CallJS("login.AccountPickerScreen.updateUserImage", user.email());
 }
 
 void SigninScreenHandler::OnPreferencesChanged() {
   // Make sure that one of the login UI is active now, otherwise
   // preferences update would be picked up next time it will be shown.
   if (!login_ui_active_) {
     LOG(WARNING) << "Login UI is not active - ignoring prefs change.";
     return;
   }
 
   if (delegate_ && !delegate_->IsShowUsers()) {
     HandleShowAddUser(NULL);
   } else {
     SendUserList(false);
     UpdateUIState(UI_STATE_ACCOUNT_PICKER, NULL);
   }
 }
 
 void SigninScreenHandler::ResetSigninScreenHandlerDelegate() {
   SetDelegate(NULL);
 }
 
 void SigninScreenHandler::ShowError(int login_attempts,
                                     const std::string& error_text,
                                     const std::string& help_link_text,
                                     HelpAppLauncher::HelpTopic help_topic_id) {
-  CallJS("cr.ui.Oobe.showSignInError",
-         base::FundamentalValue(login_attempts),
-         base::StringValue(error_text),
-         base::StringValue(help_link_text),
-         base::FundamentalValue(static_cast<int>(help_topic_id)));
+  CallJS("cr.ui.Oobe.showSignInError", login_attempts, error_text,
+         help_link_text, static_cast<int>(help_topic_id));
 }
 
 void SigninScreenHandler::ShowErrorScreen(LoginDisplay::SigninError error_id) {
   switch (error_id) {
     case LoginDisplay::TPM_ERROR:
       CallJS("cr.ui.Oobe.showTpmError");
       break;
     default:
       NOTREACHED() << "Unknown sign in error";
       break;
   }
 }
 
 void SigninScreenHandler::ShowSigninUI(const std::string& email) {
-  base::StringValue email_value(email);
-  CallJS("cr.ui.Oobe.showSigninUI", email_value);
+  CallJS("cr.ui.Oobe.showSigninUI", email);
 }
 
 void SigninScreenHandler::ShowGaiaPasswordChanged(const std::string& username) {
   email_ = username;
   password_changed_for_.insert(email_);
-  base::StringValue email_value(email_);
-  CallJS("cr.ui.Oobe.showSigninUI", email_value);
-  CallJS("login.AccountPickerScreen.updateUserGaiaNeeded", email_value);
+  CallJS("cr.ui.Oobe.showSigninUI", email_);
+  CallJS("login.AccountPickerScreen.updateUserGaiaNeeded", email_);
 }
 
 void SigninScreenHandler::ShowPasswordChangedDialog(bool show_password_error) {
-  base::FundamentalValue showError(show_password_error);
-  CallJS("cr.ui.Oobe.showPasswordChangedScreen", showError);
+  CallJS("cr.ui.Oobe.showPasswordChangedScreen", show_password_error);
 }
 
 void SigninScreenHandler::ShowSigninScreenForCreds(
     const std::string& username,
     const std::string& password) {
   VLOG(2) << "ShowSigninScreenForCreds " << username << " " << password;
 
   test_user_ = username;
   test_pass_ = password;
   HandleShowAddUser(NULL);
 }
 
 void SigninScreenHandler::SetGaiaOriginForTesting(const std::string& arg) {
   gaia_origin_for_test_ = arg;
 }
 
 void SigninScreenHandler::OnBrowsingDataRemoverDone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   cookie_remover_ = NULL;
   cookies_cleared_ = true;
   cookie_remover_callback_.Run();
   cookie_remover_callback_.Reset();
 }
 
 void SigninScreenHandler::OnCapsLockChange(bool enabled) {
-  if (page_is_ready()) {
-    base::FundamentalValue capsLockState(enabled);
-    CallJS("login.AccountPickerScreen.setCapsLockState", capsLockState);
-  }
+  if (page_is_ready())
+    CallJS("login.AccountPickerScreen.setCapsLockState", enabled);
 }
 
 void SigninScreenHandler::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_SYSTEM_SETTING_CHANGED: {
       UpdateAuthExtension();
       UpdateAddButtonStatus();
       break;
@@ skipping 133 matching lines @@
   CallJS("login.GaiaSigninScreen.loadAuthExtension", params);
 }
 
 void SigninScreenHandler::UpdateAuthExtension() {
   DictionaryValue params;
   UpdateAuthParamsFromSettings(&params, CrosSettings::Get());
   CallJS("login.GaiaSigninScreen.updateAuthExtension", params);
 }
 
 void SigninScreenHandler::UpdateAddButtonStatus() {
-  base::FundamentalValue disabled(AllWhitelistedUsersPresent());
-  CallJS("cr.ui.login.DisplayManager.updateAddUserButtonStatus", disabled);
+  CallJS("cr.ui.login.DisplayManager.updateAddUserButtonStatus",
+         AllWhitelistedUsersPresent());
 }
 
 void SigninScreenHandler::HandleCompleteLogin(const std::string& typed_email,
                                               const std::string& password) {
   if (!delegate_)
     return;
   const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
   delegate_->SetDisplayEmail(sanitized_email);
   delegate_->CompleteLogin(UserContext(sanitized_email,
                                        password,
@@ skipping 196 matching lines @@
                             !is_public_account &&
                             !signed_in &&
                             !is_signin_to_add);
 
       users_list.Append(user_dict);
       if (!is_owner)
         ++non_owner_count;
     }
   }
 
-  base::FundamentalValue animated_value(animated);
-  base::FundamentalValue guest_value(delegate_->IsShowGuest());
-  CallJS("login.AccountPickerScreen.loadUsers",
-         users_list, animated_value, guest_value);
+  CallJS("login.AccountPickerScreen.loadUsers", users_list, animated,
+         delegate_->IsShowGuest());
 }
 
 void SigninScreenHandler::HandleAccountPickerReady() {
   LOG(INFO) << "Login WebUI >> AccountPickerReady";
 
   if (delegate_ && !ScreenLocker::default_screen_locker() &&
       !chromeos::IsMachineHWIDCorrect() &&
       !oobe_ui_) {
     delegate_->ShowWrongHWIDScreen();
     return;
@@ skipping 292 matching lines @@
   if (!cros_settings)
     return false;
 
   // Offline login is allowed only when user pods are hidden.
   bool show_pods;
   cros_settings->GetBoolean(kAccountsPrefShowUserNamesOnSignIn, &show_pods);
   return !show_pods;
 }
 
 }  // namespace chromeos