Remove base::StringValue

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

 // Copyright 2016 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/about_handler.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 478 matching lines @@
       FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
                      base::TaskPriority::USER_VISIBLE),
       base::Bind(&GetVersionInfo),
       base::Bind(&AboutHandler::OnGetVersionInfoReady,
                  weak_factory_.GetWeakPtr(), callback_id));
 }
 
 void AboutHandler::OnGetVersionInfoReady(
     std::string callback_id,
     std::unique_ptr<base::DictionaryValue> version_info) {
-  ResolveJavascriptCallback(base::StringValue(callback_id), *version_info);
+  ResolveJavascriptCallback(base::Value(callback_id), *version_info);
 }
 
 void AboutHandler::HandleGetRegulatoryInfo(const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
 
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
                      base::TaskPriority::USER_VISIBLE),
@@ skipping 23 matching lines @@
 void AboutHandler::OnGetTargetChannel(std::string callback_id,
                                       const std::string& current_channel,
                                       const std::string& target_channel) {
   std::unique_ptr<base::DictionaryValue> channel_info(
       new base::DictionaryValue);
   channel_info->SetString("currentChannel", current_channel);
   channel_info->SetString("targetChannel", target_channel);
   channel_info->SetBoolean("canChangeChannel",
                            CanChangeChannel(Profile::FromWebUI(web_ui())));
 
-  ResolveJavascriptCallback(base::StringValue(callback_id), *channel_info);
+  ResolveJavascriptCallback(base::Value(callback_id), *channel_info);
 }
 
 void AboutHandler::HandleRequestUpdate(const base::ListValue* args) {
   RequestUpdate();
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 void AboutHandler::RequestUpdate() {
   version_updater_->CheckForUpdate(
@@ skipping 23 matching lines @@
     if (!types_msg.empty())
       event->SetString("connectionTypes", types_msg);
     else
       event->Set("connectionTypes", base::Value::CreateNullValue());
   } else {
     event->Set("connectionTypes", base::Value::CreateNullValue());
   }
 #endif  // defined(OS_CHROMEOS)
 
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("update-status-changed"), *event);
+                         base::Value("update-status-changed"), *event);
 }
 
 #if defined(OS_MACOSX)
 void AboutHandler::SetPromotionState(VersionUpdater::PromotionState state) {
   // Worth noting: PROMOTE_DISABLED indicates that promotion is possible,
   // there's just something else going on right now (e.g. checking for update).
   bool hidden = state == VersionUpdater::PROMOTE_HIDDEN;
   bool disabled = state == VersionUpdater::PROMOTE_HIDDEN ||
                   state == VersionUpdater::PROMOTE_DISABLED ||
                   state == VersionUpdater::PROMOTED;
   bool actionable = state == VersionUpdater::PROMOTE_DISABLED ||
                     state == VersionUpdater::PROMOTE_ENABLED;
 
   base::string16 text = base::string16();
   if (actionable)
     text = l10n_util::GetStringUTF16(IDS_ABOUT_CHROME_AUTOUPDATE_ALL);
   else if (state == VersionUpdater::PROMOTED)
     text = l10n_util::GetStringUTF16(IDS_ABOUT_CHROME_AUTOUPDATE_ALL_IS_ON);
 
   base::DictionaryValue promo_state;
   promo_state.SetBoolean("hidden", hidden);
   promo_state.SetBoolean("disabled", disabled);
   promo_state.SetBoolean("actionable", actionable);
   if (!text.empty())
     promo_state.SetString("text", text);
 
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("promotion-state-changed"),
-                         promo_state);
+                         base::Value("promotion-state-changed"), promo_state);
 }
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_CHROMEOS)
 void AboutHandler::OnRegulatoryLabelDirFound(
     std::string callback_id,
     const base::FilePath& label_dir_path) {
   if (label_dir_path.empty()) {
-    ResolveJavascriptCallback(base::StringValue(callback_id),
+    ResolveJavascriptCallback(base::Value(callback_id),
                               *base::Value::CreateNullValue());
     return;
   }
 
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
                      base::TaskPriority::USER_VISIBLE),
       base::Bind(&ReadRegulatoryLabelText, label_dir_path),
       base::Bind(&AboutHandler::OnRegulatoryLabelTextRead,
                  weak_factory_.GetWeakPtr(), callback_id, label_dir_path));
 }
 
 void AboutHandler::OnRegulatoryLabelTextRead(
     std::string callback_id,
     const base::FilePath& label_dir_path,
     const std::string& text) {
   std::unique_ptr<base::DictionaryValue> regulatory_info(
       new base::DictionaryValue);
   // Remove unnecessary whitespace.
   regulatory_info->SetString("text", base::CollapseWhitespaceASCII(text, true));
 
   std::string image_path =
       label_dir_path.AppendASCII(kRegulatoryLabelImageFilename).MaybeAsASCII();
   std::string url =
       std::string("chrome://") + chrome::kChromeOSAssetHost + "/" + image_path;
   regulatory_info->SetString("url", url);
 
-  ResolveJavascriptCallback(base::StringValue(callback_id), *regulatory_info);
+  ResolveJavascriptCallback(base::Value(callback_id), *regulatory_info);
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace settings