Remove base::FundamentalValue

content/child/v8_value_converter_impl.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 "content/child/v8_value_converter_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 343 matching lines @@
   CHECK(!val.IsEmpty());
 
   FromV8ValueState::Level state_level(state);
   if (state->HasReachedMaxRecursionDepth())
     return nullptr;
 
   if (val->IsNull())
     return base::Value::CreateNullValue();
 
   if (val->IsBoolean())
-    return base::MakeUnique<base::FundamentalValue>(
-        val->ToBoolean(isolate)->Value());
+    return base::MakeUnique<base::Value>(val->ToBoolean(isolate)->Value());
 
   if (val->IsNumber() && strategy_) {
     std::unique_ptr<base::Value> out;
     if (strategy_->FromV8Number(val.As<v8::Number>(), &out))
       return out;
   }
 
   if (val->IsInt32())
-    return base::MakeUnique<base::FundamentalValue>(
-        val->ToInt32(isolate)->Value());
+    return base::MakeUnique<base::Value>(val->ToInt32(isolate)->Value());
 
   if (val->IsNumber()) {
     double val_as_double = val.As<v8::Number>()->Value();
     if (!std::isfinite(val_as_double))
       return nullptr;
     // Normally, this would be an integer, and fall into IsInt32(). But if the
     // value is -0, it's treated internally as a double. Consumers are allowed
     // to ignore this esoterica and treat it as an integer.
     if (convert_negative_zero_to_int_ && val_as_double == 0.0)
-      return base::MakeUnique<base::FundamentalValue>(0);
-    return base::MakeUnique<base::FundamentalValue>(val_as_double);
+      return base::MakeUnique<base::Value>(0);
+    return base::MakeUnique<base::Value>(val_as_double);
   }
 
   if (val->IsString()) {
     v8::String::Utf8Value utf8(val);
     return base::MakeUnique<base::StringValue>(
         std::string(*utf8, utf8.length()));
   }
 
   if (val->IsUndefined()) {
     if (strategy_) {
       std::unique_ptr<base::Value> out;
       if (strategy_->FromV8Undefined(&out))
         return out;
     }
     // JSON.stringify ignores undefined.
     return nullptr;
   }
 
   if (val->IsDate()) {
     if (!date_allowed_)
       // JSON.stringify would convert this to a string, but an object is more
       // consistent within this class.
       return FromV8Object(val->ToObject(isolate), state, isolate);
     v8::Date* date = v8::Date::Cast(*val);
-    return base::MakeUnique<base::FundamentalValue>(date->ValueOf() / 1000.0);
+    return base::MakeUnique<base::Value>(date->ValueOf() / 1000.0);
   }
 
   if (val->IsRegExp()) {
     if (!reg_exp_allowed_)
       // JSON.stringify converts to an object.
       return FromV8Object(val.As<v8::Object>(), state, isolate);
     return base::MakeUnique<base::StringValue>(*v8::String::Utf8Value(val));
   }
 
   // v8::Value doesn't have a ToArray() method for some reason.
@@ skipping 196 matching lines @@
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     std::move(child));
   }
 
   return std::move(result);
 }
 
 }  // namespace content