Remove FundamentalValue

extensions/renderer/argument_spec.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 "extensions/renderer/argument_spec.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
 
 namespace extensions {
 
 namespace {
 
 template <class T>
 std::unique_ptr<base::Value> GetFundamentalConvertedValueHelper(
     v8::Local<v8::Value> arg,
     v8::Local<v8::Context> context,
     const base::Optional<int>& minimum) {
   T val;
   if (!gin::Converter<T>::FromV8(context->GetIsolate(), arg, &val))
     return nullptr;
   if (minimum && val < minimum.value())
     return nullptr;
-  return base::MakeUnique<base::FundamentalValue>(val);
+  return base::MakeUnique<base::Value>(val);
 }
 
 }  // namespace
 
 ArgumentSpec::ArgumentSpec(const base::Value& value)
     : type_(ArgumentType::INTEGER), optional_(false) {
   const base::DictionaryValue* dict = nullptr;
   CHECK(value.GetAsDictionary(&dict));
   dict->GetBoolean("optional", &optional_);
   dict->GetString("name", &name_);
@@ skipping 135 matching lines @@
                                                value, &s) ||
           (!enum_values_.empty() && enum_values_.count(s) == 0)) {
         return nullptr;
       }
       return base::MakeUnique<base::StringValue>(s);
     }
     case ArgumentType::BOOLEAN: {
       bool b = false;
       if (value->IsBoolean() &&
           gin::Converter<bool>::FromV8(context->GetIsolate(), value, &b)) {
-        return base::MakeUnique<base::FundamentalValue>(b);
+        return base::MakeUnique<base::Value>(b);
       }
       return nullptr;
     }
     default:
       NOTREACHED();
   }
   return nullptr;
 }
 
 std::unique_ptr<base::Value> ArgumentSpec::ConvertArgumentToObject(
@@ skipping 70 matching lines @@
   std::unique_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
   std::unique_ptr<base::Value> converted(
       converter->FromV8Value(value, context));
   if (!converted)
     *error = "Could not convert to 'any'.";
   return converted;
 }
 
 }  // namespace extensions