Remove base::FundamentalValue

content/browser/service_worker/service_worker_internals_ui.cc

 // Copyright 2014 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 "content/browser/service_worker/service_worker_internals_ui.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 17 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/url_constants.h"
 
 using base::DictionaryValue;
-using base::FundamentalValue;
 using base::ListValue;
 using base::StringValue;
 using base::Value;
 using base::WeakPtr;
 
 namespace content {
 
 namespace {
 
 using GetRegistrationsCallback =
     base::Callback<void(const std::vector<ServiceWorkerRegistrationInfo>&,
                         const std::vector<ServiceWorkerVersionInfo>&,
                         const std::vector<ServiceWorkerRegistrationInfo>&)>;
 
 void OperationCompleteCallback(WeakPtr<ServiceWorkerInternalsUI> internals,
                                int callback_id,
                                ServiceWorkerStatusCode status) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(OperationCompleteCallback, internals, callback_id, status));
     return;
   }
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (internals) {
     internals->web_ui()->CallJavascriptFunctionUnsafe(
-        "serviceworker.onOperationComplete",
-        FundamentalValue(static_cast<int>(status)),
-        FundamentalValue(callback_id));
+        "serviceworker.onOperationComplete", Value(static_cast<int>(status)),
+        Value(callback_id));
   }
 }
 
 void CallServiceWorkerVersionMethodWithVersionID(
     ServiceWorkerInternalsUI::ServiceWorkerVersionMethod method,
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64_t version_id,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
@@ skipping 177 matching lines @@
     const std::vector<ServiceWorkerVersionInfo>& live_versions,
     const std::vector<ServiceWorkerRegistrationInfo>& stored_registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!internals)
     return;
 
   std::vector<std::unique_ptr<const Value>> args;
   args.push_back(GetRegistrationListValue(live_registrations));
   args.push_back(GetVersionListValue(live_versions));
   args.push_back(GetRegistrationListValue(stored_registrations));
-  args.push_back(base::MakeUnique<FundamentalValue>(partition_id));
+  args.push_back(base::MakeUnique<Value>(partition_id));
   args.push_back(base::MakeUnique<StringValue>(context_path.value()));
   internals->web_ui()->CallJavascriptFunctionUnsafe(
       "serviceworker.onPartitionData", ConvertToRawPtrVector(args));
 }
 
 }  // namespace
 
 class ServiceWorkerInternalsUI::PartitionObserver
     : public ServiceWorkerContextObserver {
  public:
   PartitionObserver(int partition_id, WebUI* web_ui)
       : partition_id_(partition_id), web_ui_(web_ui) {}
   ~PartitionObserver() override {}
   // ServiceWorkerContextObserver overrides:
   void OnRunningStateChanged(int64_t version_id,
                              EmbeddedWorkerStatus) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     web_ui_->CallJavascriptFunctionUnsafe(
-        "serviceworker.onRunningStateChanged", FundamentalValue(partition_id_),
+        "serviceworker.onRunningStateChanged", Value(partition_id_),
         StringValue(base::Int64ToString(version_id)));
   }
   void OnVersionStateChanged(int64_t version_id,
                              ServiceWorkerVersion::Status) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     web_ui_->CallJavascriptFunctionUnsafe(
-        "serviceworker.onVersionStateChanged", FundamentalValue(partition_id_),
+        "serviceworker.onVersionStateChanged", Value(partition_id_),
         StringValue(base::Int64ToString(version_id)));
   }
   void OnErrorReported(int64_t version_id,
                        int process_id,
                        int thread_id,
                        const ErrorInfo& info) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     std::vector<std::unique_ptr<const Value>> args;
-    args.push_back(base::MakeUnique<FundamentalValue>(partition_id_));
+    args.push_back(base::MakeUnique<Value>(partition_id_));
     args.push_back(
         base::MakeUnique<StringValue>(base::Int64ToString(version_id)));
-    args.push_back(base::MakeUnique<FundamentalValue>(process_id));
-    args.push_back(base::MakeUnique<FundamentalValue>(thread_id));
+    args.push_back(base::MakeUnique<Value>(process_id));
+    args.push_back(base::MakeUnique<Value>(thread_id));
     auto value = base::MakeUnique<DictionaryValue>();
     value->SetString("message", info.error_message);
     value->SetInteger("lineNumber", info.line_number);
     value->SetInteger("columnNumber", info.column_number);
     value->SetString("sourceURL", info.source_url.spec());
     args.push_back(std::move(value));
     web_ui_->CallJavascriptFunctionUnsafe("serviceworker.onErrorReported",
                                           ConvertToRawPtrVector(args));
   }
   void OnReportConsoleMessage(int64_t version_id,
                               int process_id,
                               int thread_id,
                               const ConsoleMessage& message) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     std::vector<std::unique_ptr<const Value>> args;
-    args.push_back(base::MakeUnique<FundamentalValue>(partition_id_));
+    args.push_back(base::MakeUnique<Value>(partition_id_));
     args.push_back(
         base::MakeUnique<StringValue>(base::Int64ToString(version_id)));
-    args.push_back(base::MakeUnique<FundamentalValue>(process_id));
-    args.push_back(base::MakeUnique<FundamentalValue>(thread_id));
+    args.push_back(base::MakeUnique<Value>(process_id));
+    args.push_back(base::MakeUnique<Value>(thread_id));
     auto value = base::MakeUnique<DictionaryValue>();
     value->SetInteger("sourceIdentifier", message.source_identifier);
     value->SetInteger("message_level", message.message_level);
     value->SetString("message", message.message);
     value->SetInteger("lineNumber", message.line_number);
     value->SetString("sourceURL", message.source_url.spec());
     args.push_back(std::move(value));
     web_ui_->CallJavascriptFunctionUnsafe(
         "serviceworker.onConsoleMessageReported", ConvertToRawPtrVector(args));
   }
@@ skipping 279 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
 
   // ServiceWorkerContextWrapper::UnregisterServiceWorker doesn't work here
   // because that reduces a status code to boolean.
   context->context()->UnregisterServiceWorker(scope, callback);
 }
 
 }  // namespace content