Remove base::StringValue

chrome/browser/ui/webui/settings/chromeos/cups_printers_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/chromeos/cups_printers_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 130 matching lines @@
   base::ListValue* printers_list = new base::ListValue;
   for (const std::unique_ptr<Printer>& printer : printers) {
     std::unique_ptr<base::DictionaryValue> printer_info =
         GetPrinterInfo(*printer.get());
     printers_list->Append(std::move(printer_info));
   }
 
   std::unique_ptr<base::DictionaryValue> response =
       base::MakeUnique<base::DictionaryValue>();
   response->Set("printerList", printers_list);
-  ResolveJavascriptCallback(base::StringValue(callback_id), *response);
+  ResolveJavascriptCallback(base::Value(callback_id), *response);
 }
 
 void CupsPrintersHandler::HandleUpdateCupsPrinter(const base::ListValue* args) {
   std::string printer_id;
   std::string printer_name;
   CHECK(args->GetString(0, &printer_id));
   CHECK(args->GetString(1, &printer_name));
 
   std::unique_ptr<Printer> printer = base::MakeUnique<Printer>(printer_id);
   printer->set_display_name(printer_name);
@@ skipping 82 matching lines @@
 
 void CupsPrintersHandler::OnAddedPrinter(std::unique_ptr<Printer> printer,
                                          chromeos::SetupResult result_code) {
   std::string printer_name = printer->display_name();
   bool success = (result_code == chromeos::SetupResult::SUCCESS);
   if (success) {
     PrintersManagerFactory::GetForBrowserContext(profile_)->RegisterPrinter(
         std::move(printer));
   }
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("on-add-cups-printer"),
-                         base::Value(success), base::StringValue(printer_name));
+                         base::Value("on-add-cups-printer"),
+                         base::Value(success), base::Value(printer_name));
 }
 
 void CupsPrintersHandler::OnAddPrinterError() {
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("on-add-cups-printer"),
-                         base::Value(false), base::StringValue(""));
+                         base::Value("on-add-cups-printer"), base::Value(false),
+                         base::Value(""));
 }
 
 void CupsPrintersHandler::HandleGetCupsPrinterManufacturers(
     const base::ListValue* args) {
   AllowJavascript();
   std::string js_callback;
   CHECK_EQ(1U, args->GetSize());
   CHECK(args->GetString(0, &js_callback));
   ppd_provider_->ResolveManufacturers(
       base::Bind(&CupsPrintersHandler::ResolveManufacturersDone,
                  weak_factory_.GetWeakPtr(), js_callback));
 }
 
 void CupsPrintersHandler::HandleGetCupsPrinterModels(
     const base::ListValue* args) {
   AllowJavascript();
   std::string js_callback;
   std::string manufacturer;
   CHECK_EQ(2U, args->GetSize());
   CHECK(args->GetString(0, &js_callback));
   CHECK(args->GetString(1, &manufacturer));
 
   // Empty manufacturer queries may be triggered as a part of the ui
   // initialization, and should just return empty results.
   if (manufacturer.empty()) {
     base::DictionaryValue response;
     response.SetBoolean("success", true);
     response.Set("models", base::MakeUnique<base::ListValue>());
-    ResolveJavascriptCallback(base::StringValue(js_callback), response);
+    ResolveJavascriptCallback(base::Value(js_callback), response);
     return;
   }
 
   ppd_provider_->ResolvePrinters(
       manufacturer, base::Bind(&CupsPrintersHandler::ResolvePrintersDone,
                                weak_factory_.GetWeakPtr(), js_callback));
 }
 
 void CupsPrintersHandler::HandleSelectPPDFile(const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
@@ skipping 20 matching lines @@
     chromeos::printing::PpdProvider::CallbackResultCode result_code,
     const std::vector<std::string>& manufacturers) {
   auto manufacturers_value = base::MakeUnique<base::ListValue>();
   if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
     manufacturers_value->AppendStrings(manufacturers);
   }
   base::DictionaryValue response;
   response.SetBoolean("success",
                       result_code == chromeos::printing::PpdProvider::SUCCESS);
   response.Set("manufacturers", std::move(manufacturers_value));
-  ResolveJavascriptCallback(base::StringValue(js_callback), response);
+  ResolveJavascriptCallback(base::Value(js_callback), response);
 }
 
 void CupsPrintersHandler::ResolvePrintersDone(
     const std::string& js_callback,
     chromeos::printing::PpdProvider::CallbackResultCode result_code,
     const std::vector<std::string>& printers) {
   auto printers_value = base::MakeUnique<base::ListValue>();
   if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
     printers_value->AppendStrings(printers);
   }
   base::DictionaryValue response;
   response.SetBoolean("success",
                       result_code == chromeos::printing::PpdProvider::SUCCESS);
   response.Set("models", std::move(printers_value));
-  ResolveJavascriptCallback(base::StringValue(js_callback), response);
+  ResolveJavascriptCallback(base::Value(js_callback), response);
 }
 
 void CupsPrintersHandler::FileSelected(const base::FilePath& path,
                                        int index,
                                        void* params) {
   DCHECK(!webui_callback_id_.empty());
-  ResolveJavascriptCallback(base::StringValue(webui_callback_id_),
-                            base::StringValue(path.value()));
+  ResolveJavascriptCallback(base::Value(webui_callback_id_),
+                            base::Value(path.value()));
   webui_callback_id_.clear();
 }
 
 void CupsPrintersHandler::HandleStartDiscovery(const base::ListValue* args) {
   if (!printer_discoverer_.get())
     printer_discoverer_ = chromeos::PrinterDiscoverer::Create();
 
   printer_discoverer_->AddObserver(this);
   if (!printer_discoverer_->StartDiscovery()) {
     CallJavascriptFunction("cr.webUIListenerCallback",
-                           base::StringValue("on-printer-discovery-failed"));
+                           base::Value("on-printer-discovery-failed"));
     printer_discoverer_->RemoveObserver(this);
   }
 }
 
 void CupsPrintersHandler::HandleStopDiscovery(const base::ListValue* args) {
   if (printer_discoverer_.get()) {
     printer_discoverer_->RemoveObserver(this);
     printer_discoverer_->StopDiscovery();
     printer_discoverer_.reset();
   }
 }
 
 void CupsPrintersHandler::OnPrintersFound(
     const std::vector<Printer>& printers) {
   std::unique_ptr<base::ListValue> printers_list =
       base::MakeUnique<base::ListValue>();
   for (const auto& printer : printers) {
     std::unique_ptr<base::DictionaryValue> printer_info =
         GetPrinterInfo(printer);
     printers_list->Append(std::move(printer_info));
   }
 
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("on-printer-discovered"),
-                         *printers_list);
+                         base::Value("on-printer-discovered"), *printers_list);
 }
 
 void CupsPrintersHandler::OnDiscoveryDone() {
   CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::StringValue("on-printer-discovery-done"));
+                         base::Value("on-printer-discovery-done"));
 }
 
 }  // namespace settings
 }  // namespace chromeos