Remove base::StringValue

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 306 matching lines @@
   configuring_sync_ = true;
 
   const int kTimeoutSec = 30;
   DCHECK(!engine_start_timer_);
   engine_start_timer_.reset(new base::OneShotTimer());
   engine_start_timer_->Start(FROM_HERE,
                              base::TimeDelta::FromSeconds(kTimeoutSec), this,
                              &PeopleHandler::DisplayTimeout);
 
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("page-status-changed"),
-                         base::StringValue(kSpinnerPageStatus));
+                         base::Value("page-status-changed"),
+                         base::Value(kSpinnerPageStatus));
 }
 
 void PeopleHandler::DisplayTimeout() {
   // Stop a timer to handle timeout in waiting for checking network connection.
   engine_start_timer_.reset();
 
   // Do not listen to sync startup events.
   sync_startup_tracker_.reset();
 
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("page-status-changed"),
-                         base::StringValue(kTimeoutPageStatus));
+                         base::Value("page-status-changed"),
+                         base::Value(kTimeoutPageStatus));
 }
 
 void PeopleHandler::OnDidClosePage(const base::ListValue* args) {
   MarkFirstSetupComplete();
   CloseSyncSetup();
 }
 
 void PeopleHandler::SyncStartupFailed() {
   // Stop a timer to handle timeout in waiting for checking network connection.
   engine_start_timer_.reset();
@@ skipping 33 matching lines @@
                            configuration.payments_integration_enabled);
 
   // Start configuring the ProfileSyncService using the configuration passed
   // to us from the JS layer.
   ProfileSyncService* service = GetSyncService();
 
   // If the sync engine has shutdown for some reason, just close the sync
   // dialog.
   if (!service || !service->IsEngineInitialized()) {
     CloseSyncSetup();
-    ResolveJavascriptCallback(*callback_id, base::StringValue(kDonePageStatus));
+    ResolveJavascriptCallback(*callback_id, base::Value(kDonePageStatus));
     return;
   }
 
   service->OnUserChoseDatatypes(configuration.sync_everything,
                                 configuration.data_types);
 
   // Choosing data types to sync never fails.
-  ResolveJavascriptCallback(*callback_id,
-                            base::StringValue(kConfigurePageStatus));
+  ResolveJavascriptCallback(*callback_id, base::Value(kConfigurePageStatus));
 
   ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_CUSTOMIZE);
   if (!configuration.sync_everything)
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_CHOOSE);
 }
 
 void PeopleHandler::HandleSetEncryption(const base::ListValue* args) {
   DCHECK(!sync_startup_tracker_);
 
   SyncConfigInfo configuration;
   const base::Value* callback_id = nullptr;
   ParseConfigurationArguments(args, &configuration, &callback_id);
 
   // Start configuring the ProfileSyncService using the configuration passed
   // to us from the JS layer.
   ProfileSyncService* service = GetSyncService();
 
   // If the sync engine has shutdown for some reason, just close the sync
   // dialog.
   if (!service || !service->IsEngineInitialized()) {
     CloseSyncSetup();
-    ResolveJavascriptCallback(*callback_id, base::StringValue(kDonePageStatus));
+    ResolveJavascriptCallback(*callback_id, base::Value(kDonePageStatus));
     return;
   }
 
   // Don't allow "encrypt all" if the ProfileSyncService doesn't allow it.
   // The UI is hidden, but the user may have enabled it e.g. by fiddling with
   // the web inspector.
   if (!service->IsEncryptEverythingAllowed())
     configuration.encrypt_all = false;
 
   // Note: Data encryption will not occur until configuration is complete
@@ skipping 30 matching lines @@
 
   if (passphrase_failed || service->IsPassphraseRequiredForDecryption()) {
     // If the user doesn't enter any passphrase, we won't call
     // SetDecryptionPassphrase() (passphrase_failed == false), but we still
     // want to display an error message to let the user know that their blank
     // passphrase entry is not acceptable.
 
     // TODO(tommycli): Switch this to RejectJavascriptCallback once the
     // Sync page JavaScript has been further refactored.
     ResolveJavascriptCallback(*callback_id,
-                              base::StringValue(kPassphraseFailedPageStatus));
+                              base::Value(kPassphraseFailedPageStatus));
   } else {
-    ResolveJavascriptCallback(*callback_id,
-                              base::StringValue(kConfigurePageStatus));
+    ResolveJavascriptCallback(*callback_id, base::Value(kConfigurePageStatus));
   }
 
   if (configuration.encrypt_all)
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_ENCRYPT);
   if (!configuration.set_new_passphrase && !configuration.passphrase.empty())
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_PASSPHRASE);
 }
 
 void PeopleHandler::HandleShowSetupUI(const base::ListValue* args) {
   AllowJavascript();
@@ skipping 201 matching lines @@
 }
 
 void PeopleHandler::FocusUI() {
   WebContents* web_contents = web_ui()->GetWebContents();
   web_contents->GetDelegate()->ActivateContents(web_contents);
 }
 
 void PeopleHandler::CloseUI() {
   CloseSyncSetup();
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("page-status-changed"),
-                         base::StringValue(kDonePageStatus));
+                         base::Value("page-status-changed"),
+                         base::Value(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 168 matching lines @@
         args.SetString("fullEncryptionBody",
                        GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
         break;
     }
   } else if (passphrase_type == syncer::PassphraseType::CUSTOM_PASSPHRASE) {
     args.SetString("fullEncryptionBody",
                    GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
   }
 
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("sync-prefs-changed"), args);
+                         base::Value("sync-prefs-changed"), args);
 }
 
 LoginUIService* PeopleHandler::GetLoginUIService() const {
   return LoginUIServiceFactory::GetForProfile(profile_);
 }
 
 void PeopleHandler::UpdateSyncStatus() {
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("sync-status-changed"),
+                         base::Value("sync-status-changed"),
                          *GetSyncStatusDictionary());
 }
 
 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();
   // The sync service may be nullptr if it has been just disabled by policy.
   if (!service || 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.
   sync_blocker_.reset();
   service->SetFirstSetupComplete();
 }
 
 }  // namespace settings