Remove base::StringValue

chrome/browser/ui/webui/print_preview/print_preview_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/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 #include <stddef.h>
 
 #include <map>
@@ skipping 1077 matching lines @@
 
 // |args| is expected to contain a string with representing the callback id
 // followed by a list of arguments the first of which should be the printer id.
 void PrintPreviewHandler::HandlePrinterSetup(const base::ListValue* args) {
   AllowJavascript();
 
   std::string callback_id;
   std::string printer_name;
   if (!args->GetString(0, &callback_id) || !args->GetString(1, &printer_name) ||
       callback_id.empty() || printer_name.empty()) {
-    RejectJavascriptCallback(base::StringValue(callback_id),
-                             base::StringValue(printer_name));
+    RejectJavascriptCallback(base::Value(callback_id),
+                             base::Value(printer_name));
     return;
   }
 
   printer_backend_proxy()->ConfigurePrinterAndFetchCapabilities(
       printer_name,
       base::Bind(&PrintPreviewHandler::SendPrinterSetup,
                  weak_factory_.GetWeakPtr(), callback_id, printer_name));
 }
 
 void PrintPreviewHandler::OnSigninComplete() {
@@ skipping 170 matching lines @@
                                          initial_settings);
 }
 
 void PrintPreviewHandler::ClosePreviewDialog() {
   print_preview_ui()->OnClosePrintPreviewDialog();
 }
 
 void PrintPreviewHandler::SendAccessToken(const std::string& type,
                                           const std::string& access_token) {
   VLOG(1) << "Get getAccessToken finished";
-  web_ui()->CallJavascriptFunctionUnsafe("onDidGetAccessToken",
-                                         base::StringValue(type),
-                                         base::StringValue(access_token));
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "onDidGetAccessToken", base::Value(type), base::Value(access_token));
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
     const std::string& printer_name,
     std::unique_ptr<base::DictionaryValue> settings_info) {
   if (!settings_info) {
     VLOG(1) << "Get printer capabilities failed";
     web_ui()->CallJavascriptFunctionUnsafe("failedToGetPrinterCapabilities",
-                                           base::StringValue(printer_name));
+                                           base::Value(printer_name));
     return;
   }
   VLOG(1) << "Get printer capabilities finished";
   web_ui()->CallJavascriptFunctionUnsafe("updateWithPrinterCapabilities",
                                          *settings_info);
 }
 
 void PrintPreviewHandler::SendPrinterSetup(
     const std::string& callback_id,
     const std::string& printer_name,
     std::unique_ptr<base::DictionaryValue> destination_info) {
   auto response = base::MakeUnique<base::DictionaryValue>();
   bool success = true;
   auto caps_value = base::Value::CreateNullValue();
   auto caps = base::MakeUnique<base::DictionaryValue>();
   if (destination_info &&
       destination_info->Remove(printing::kPrinterCapabilities, &caps_value) &&
       caps_value->IsType(base::Value::Type::DICTIONARY)) {
     caps = base::DictionaryValue::From(std::move(caps_value));
   } else {
     LOG(WARNING) << "Printer setup failed";
     success = false;
   }
 
   response->SetString("printerId", printer_name);
   response->SetBoolean("success", success);
   response->Set("capabilities", std::move(caps));
 
-  ResolveJavascriptCallback(base::StringValue(callback_id), *response);
+  ResolveJavascriptCallback(base::Value(callback_id), *response);
 }
 
 void PrintPreviewHandler::SetupPrinterList(
     const printing::PrinterList& printer_list) {
   base::ListValue printers;
   PrintersToValues(printer_list, &printers);
 
   VLOG(1) << "Enumerate printers finished, found " << printers.GetSize()
           << " printers";
 
@@ skipping 17 matching lines @@
     web_ui()->CallJavascriptFunctionUnsafe("setUseCloudPrint", settings);
   }
 }
 
 void PrintPreviewHandler::SendCloudPrintJob(const base::RefCountedBytes* data) {
   // BASE64 encode the job data.
   const base::StringPiece raw_data(reinterpret_cast<const char*>(data->front()),
                                    data->size());
   std::string base64_data;
   base::Base64Encode(raw_data, &base64_data);
-  base::StringValue data_value(base64_data);
+  base::Value data_value(base64_data);
 
   web_ui()->CallJavascriptFunctionUnsafe("printToCloud", data_value);
 }
 
 WebContents* PrintPreviewHandler::GetInitiator() const {
   printing::PrintPreviewDialogController* dialog_controller =
       printing::PrintPreviewDialogController::GetInstance();
   if (!dialog_controller)
     return NULL;
   return dialog_controller->GetInitiator(preview_web_contents());
@@ skipping 272 matching lines @@
   FillPrinterDescription(name, *description, true, &printer_info);
 
   web_ui()->CallJavascriptFunctionUnsafe("onPrivetCapabilitiesSet",
                                          printer_info, *capabilities);
 
   privet_capabilities_operation_.reset();
 }
 
 void PrintPreviewHandler::SendPrivetCapabilitiesError(
     const std::string& device_name) {
-  base::StringValue name_value(device_name);
+  base::Value name_value(device_name);
   web_ui()->CallJavascriptFunctionUnsafe("failedToGetPrivetPrinterCapabilities",
                                          name_value);
 }
 
 void PrintPreviewHandler::PrintToPrivetPrinter(const std::string& device_name,
                                                const std::string& ticket,
                                                const std::string& capabilities,
                                                const gfx::Size& page_size) {
   CreatePrivetHTTP(
       device_name,
@@ skipping 69 matching lines @@
     bool done) {
   web_ui()->CallJavascriptFunctionUnsafe("onExtensionPrintersAdded", printers,
                                          base::Value(done));
 }
 
 void PrintPreviewHandler::OnGotExtensionPrinterInfo(
     const std::string& printer_id,
     const base::DictionaryValue& printer_info) {
   if (printer_info.empty()) {
     web_ui()->CallJavascriptFunctionUnsafe("failedToResolveProvisionalPrinter",
-                                           base::StringValue(printer_id));
+                                           base::Value(printer_id));
     return;
   }
 
   web_ui()->CallJavascriptFunctionUnsafe("onProvisionalPrinterResolved",
-                                         base::StringValue(printer_id),
-                                         printer_info);
+                                         base::Value(printer_id), printer_info);
 }
 
 void PrintPreviewHandler::OnGotExtensionPrinterCapabilities(
     const std::string& printer_id,
     const base::DictionaryValue& capabilities) {
   if (capabilities.empty()) {
     web_ui()->CallJavascriptFunctionUnsafe(
-        "failedToGetExtensionPrinterCapabilities",
-        base::StringValue(printer_id));
+        "failedToGetExtensionPrinterCapabilities", base::Value(printer_id));
     return;
   }
 
   web_ui()->CallJavascriptFunctionUnsafe("onExtensionCapabilitiesSet",
-                                         base::StringValue(printer_id),
-                                         capabilities);
+                                         base::Value(printer_id), capabilities);
 }
 
 void PrintPreviewHandler::OnExtensionPrintResult(bool success,
                                                  const std::string& status) {
   if (success) {
     ClosePreviewDialog();
     return;
   }
 
   // TODO(tbarzic): This function works for extension printers case too, but it
   // should be renamed to something more generic.
   web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
-                                         base::StringValue(status));
+                                         base::Value(status));
 }
 
 void PrintPreviewHandler::RegisterForGaiaCookieChanges() {
   DCHECK(!gaia_cookie_manager_service_);
   Profile* profile = Profile::FromWebUI(web_ui());
   if (switches::IsEnableAccountConsistency() && !profile->IsOffTheRecord()) {
     gaia_cookie_manager_service_ =
         GaiaCookieManagerServiceFactory::GetForProfile(profile);
     if (gaia_cookie_manager_service_)
       gaia_cookie_manager_service_->AddObserver(this);
   }
 }
 
 void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }