Remove base::StringValue

chrome/browser/ui/webui/offline/offline_internals_ui_message_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/offline/offline_internals_ui_message_handler.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <vector>
 
@@ skipping 97 matching lines @@
         offline_ids,
         base::Bind(
             &OfflineInternalsUIMessageHandler::HandleDeletedRequestsCallback,
             weak_ptr_factory_.GetWeakPtr(), callback_id));
   }
 }
 
 void OfflineInternalsUIMessageHandler::HandleDeletedPagesCallback(
     std::string callback_id,
     offline_pages::DeletePageResult result) {
-  ResolveJavascriptCallback(
-      base::StringValue(callback_id),
-      base::StringValue(GetStringFromDeletePageResult(result)));
+  ResolveJavascriptCallback(base::Value(callback_id),
+                            base::Value(GetStringFromDeletePageResult(result)));
 }
 
 void OfflineInternalsUIMessageHandler::HandleDeletedRequestsCallback(
     std::string callback_id,
     const offline_pages::MultipleItemStatuses& results) {
   ResolveJavascriptCallback(
-      base::StringValue(callback_id),
-      base::StringValue(GetStringFromDeleteRequestResults(results)));
+      base::Value(callback_id),
+      base::Value(GetStringFromDeleteRequestResults(results)));
 }
 
 void OfflineInternalsUIMessageHandler::HandleStoredPagesCallback(
     std::string callback_id,
     const offline_pages::MultipleOfflinePageItemResult& pages) {
   base::ListValue results;
 
   for (const auto& page : pages) {
     base::DictionaryValue* offline_page = new base::DictionaryValue();
     results.Append(offline_page);
     offline_page->SetString("onlineUrl", page.url.spec());
     offline_page->SetString("namespace", page.client_id.name_space);
     offline_page->SetDouble("size", page.file_size);
     offline_page->SetString("id", std::to_string(page.offline_id));
     offline_page->SetString("filePath", page.file_path.MaybeAsASCII());
     offline_page->SetDouble("creationTime", page.creation_time.ToJsTime());
     offline_page->SetDouble("lastAccessTime", page.last_access_time.ToJsTime());
     offline_page->SetInteger("accessCount", page.access_count);
     offline_page->SetString("originalUrl", page.original_url.spec());
   }
-  ResolveJavascriptCallback(base::StringValue(callback_id), results);
+  ResolveJavascriptCallback(base::Value(callback_id), results);
 }
 
 void OfflineInternalsUIMessageHandler::HandleRequestQueueCallback(
     std::string callback_id,
     offline_pages::GetRequestsResult result,
     std::vector<std::unique_ptr<offline_pages::SavePageRequest>> requests) {
   base::ListValue save_page_requests;
   if (result == offline_pages::GetRequestsResult::SUCCESS) {
     for (const auto& request : requests) {
       base::DictionaryValue* save_page_request = new base::DictionaryValue();
       save_page_requests.Append(save_page_request);
       save_page_request->SetString("onlineUrl", request->url().spec());
       save_page_request->SetDouble("creationTime",
                                    request->creation_time().ToJsTime());
       save_page_request->SetString("status", GetStringFromSavePageStatus());
       save_page_request->SetString("namespace",
                                    request->client_id().name_space);
       save_page_request->SetDouble("lastAttempt",
                                    request->last_attempt_time().ToJsTime());
       save_page_request->SetString("id", std::to_string(request->request_id()));
       save_page_request->SetString("originalUrl",
                                    request->original_url().spec());
     }
   }
-  ResolveJavascriptCallback(base::StringValue(callback_id), save_page_requests);
+  ResolveJavascriptCallback(base::Value(callback_id), save_page_requests);
 }
 
 void OfflineInternalsUIMessageHandler::HandleGetRequestQueue(
     const base::ListValue* args) {
   AllowJavascript();
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
 
   if (request_coordinator_) {
     request_coordinator_->queue()->GetRequests(base::Bind(
         &OfflineInternalsUIMessageHandler::HandleRequestQueueCallback,
         weak_ptr_factory_.GetWeakPtr(), callback_id));
   } else {
     base::ListValue results;
-    ResolveJavascriptCallback(base::StringValue(callback_id), results);
+    ResolveJavascriptCallback(base::Value(callback_id), results);
   }
 }
 
 void OfflineInternalsUIMessageHandler::HandleGetStoredPages(
     const base::ListValue* args) {
   AllowJavascript();
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
 
   if (offline_page_model_) {
     offline_page_model_->GetAllPages(
         base::Bind(&OfflineInternalsUIMessageHandler::HandleStoredPagesCallback,
                    weak_ptr_factory_.GetWeakPtr(), callback_id));
   } else {
     base::ListValue results;
-    ResolveJavascriptCallback(base::StringValue(callback_id), results);
+    ResolveJavascriptCallback(base::Value(callback_id), results);
   }
 }
 
 void OfflineInternalsUIMessageHandler::HandleSetRecordPageModel(
     const base::ListValue* args) {
   bool should_record;
   CHECK(args->GetBoolean(0, &should_record));
   if (offline_page_model_)
     offline_page_model_->GetLogger()->SetIsLogging(should_record);
 }
 
 void OfflineInternalsUIMessageHandler::HandleGetNetworkStatus(
     const base::ListValue* args) {
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
 
   ResolveJavascriptCallback(
       *callback_id,
-      base::StringValue(net::NetworkChangeNotifier::IsOffline() ? "Offline"
-                                                                : "Online"));
+      base::Value(net::NetworkChangeNotifier::IsOffline() ? "Offline"
+                                                          : "Online"));
 }
 
 void OfflineInternalsUIMessageHandler::HandleSetRecordRequestQueue(
     const base::ListValue* args) {
   bool should_record;
   CHECK(args->GetBoolean(0, &should_record));
   if (request_coordinator_)
     request_coordinator_->GetLogger()->SetIsLogging(should_record);
 }
 
@@ skipping 105 matching lines @@
 
   // Get the offline page model associated with this web ui.
   Profile* profile = Profile::FromWebUI(web_ui());
   offline_page_model_ =
       offline_pages::OfflinePageModelFactory::GetForBrowserContext(profile);
   request_coordinator_ =
       offline_pages::RequestCoordinatorFactory::GetForBrowserContext(profile);
 }
 
 }  // namespace offline_internals