Remove base::StringValue

chrome/browser/ui/webui/help/help_handler.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/help/help_handler.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 465 matching lines @@
       base::Bind(&chromeos::version_loader::GetFirmware),
       base::Bind(&HelpHandler::OnOSFirmware, weak_factory_.GetWeakPtr()));
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "help.HelpPage.updateEnableReleaseChannel",
       base::Value(CanChangeChannel(Profile::FromWebUI(web_ui()))));
 
   base::Time build_time = base::SysInfo::GetLsbReleaseTime();
   base::string16 build_date = base::TimeFormatFriendlyDate(build_time);
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setBuildDate",
-                                         base::StringValue(build_date));
+                                         base::Value(build_date));
 #endif  // defined(OS_CHROMEOS)
 
   RefreshUpdateStatus();
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "help.HelpPage.setObsoleteSystem",
       base::Value(ObsoleteSystem::IsObsoleteNowOrSoon()));
   web_ui()->CallJavascriptFunctionUnsafe(
       "help.HelpPage.setObsoleteSystemEndOfTheLine",
       base::Value(ObsoleteSystem::IsObsoleteNowOrSoon() &&
@@ skipping 133 matching lines @@
     break;
   case VersionUpdater::DISABLED:
     status_str = "disabled";
     break;
   case VersionUpdater::DISABLED_BY_ADMIN:
     status_str = "disabled_by_admin";
     break;
   }
 
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setUpdateStatus",
-                                         base::StringValue(status_str),
-                                         base::StringValue(message));
+                                         base::Value(status_str),
+                                         base::Value(message));
 
   if (status == VersionUpdater::UPDATING) {
     web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setProgress",
                                            base::Value(progress));
   }
 
 #if defined(OS_CHROMEOS)
   if (status == VersionUpdater::FAILED_OFFLINE ||
       status == VersionUpdater::FAILED_CONNECTION_TYPE_DISALLOWED) {
     base::string16 types_msg = GetAllowedConnectionTypesMessage();
     if (!types_msg.empty()) {
       web_ui()->CallJavascriptFunctionUnsafe(
           "help.HelpPage.setAndShowAllowedConnectionTypesMsg",
-          base::StringValue(types_msg));
+          base::Value(types_msg));
     } else {
       web_ui()->CallJavascriptFunctionUnsafe(
           "help.HelpPage.showAllowedConnectionTypesMsg", base::Value(false));
     }
   } else {
     web_ui()->CallJavascriptFunctionUnsafe(
         "help.HelpPage.showAllowedConnectionTypesMsg", base::Value(false));
   }
 #endif  // defined(OS_CHROMEOS)
 }
 
 #if defined(OS_MACOSX)
 void HelpHandler::SetPromotionState(VersionUpdater::PromotionState state) {
   std::string state_str;
   switch (state) {
   case VersionUpdater::PROMOTE_HIDDEN:
   case VersionUpdater::PROMOTED:
     state_str = "hidden";
     break;
   case VersionUpdater::PROMOTE_ENABLED:
     state_str = "enabled";
     break;
   case VersionUpdater::PROMOTE_DISABLED:
     state_str = "disabled";
     break;
   }
 
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setPromotionState",
-                                         base::StringValue(state_str));
+                                         base::Value(state_str));
 }
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_CHROMEOS)
 void HelpHandler::OnOSVersion(const std::string& version) {
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setOSVersion",
-                                         base::StringValue(version));
+                                         base::Value(version));
 }
 
 void HelpHandler::OnARCVersion(const std::string& firmware) {
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setARCVersion",
-                                         base::StringValue(firmware));
+                                         base::Value(firmware));
 }
 
 void HelpHandler::OnOSFirmware(const std::string& firmware) {
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setOSFirmware",
-                                         base::StringValue(firmware));
+                                         base::Value(firmware));
 }
 
 void HelpHandler::OnCurrentChannel(const std::string& channel) {
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.updateCurrentChannel",
-                                         base::StringValue(channel));
+                                         base::Value(channel));
 }
 
 void HelpHandler::OnTargetChannel(const std::string& channel) {
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.updateTargetChannel",
-                                         base::StringValue(channel));
+                                         base::Value(channel));
 }
 
 void HelpHandler::OnRegulatoryLabelDirFound(const base::FilePath& path) {
   if (path.empty())
     return;
 
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
                      base::TaskPriority::BACKGROUND),
       base::Bind(&ReadRegulatoryLabelText, path),
       base::Bind(&HelpHandler::OnRegulatoryLabelTextRead,
                  weak_factory_.GetWeakPtr()));
 
   // Send the image path to the WebUI.
   OnRegulatoryLabelImageFound(path.AppendASCII(kRegulatoryLabelImageFilename));
 }
 
 void HelpHandler::OnRegulatoryLabelImageFound(const base::FilePath& path) {
   std::string url = std::string("chrome://") + chrome::kChromeOSAssetHost +
       "/" + path.MaybeAsASCII();
   web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.setRegulatoryLabelPath",
-                                         base::StringValue(url));
+                                         base::Value(url));
 }
 
 void HelpHandler::OnRegulatoryLabelTextRead(const std::string& text) {
   // Remove unnecessary whitespace.
   web_ui()->CallJavascriptFunctionUnsafe(
       "help.HelpPage.setRegulatoryLabelText",
-      base::StringValue(base::CollapseWhitespaceASCII(text, true)));
+      base::Value(base::CollapseWhitespaceASCII(text, true)));
 }
 
 void HelpHandler::OnEolStatus(update_engine::EndOfLifeStatus status) {
   // Security only state is no longer supported.
   if (status == update_engine::EndOfLifeStatus::kSecurityOnly ||
       IsEnterpriseManaged()) {
     return;
   }
 
   if (status == update_engine::EndOfLifeStatus::kSupported) {
-    web_ui()->CallJavascriptFunctionUnsafe(
-        "help.HelpPage.updateEolMessage", base::StringValue("device_supported"),
-        base::StringValue(""));
+    web_ui()->CallJavascriptFunctionUnsafe("help.HelpPage.updateEolMessage",
+                                           base::Value("device_supported"),
+                                           base::Value(""));
   } else {
     web_ui()->CallJavascriptFunctionUnsafe(
-        "help.HelpPage.updateEolMessage", base::StringValue("device_endoflife"),
-        base::StringValue(l10n_util::GetStringUTF16(IDS_ABOUT_PAGE_EOL_EOL)));
+        "help.HelpPage.updateEolMessage", base::Value("device_endoflife"),
+        base::Value(l10n_util::GetStringUTF16(IDS_ABOUT_PAGE_EOL_EOL)));
   }
 }
 
 #endif  // defined(OS_CHROMEOS)