Remove base::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 "extensions/renderer/api_type_reference_map.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
 
 namespace extensions {
 
 namespace {
 
 template <class T>
 bool ParseFundamentalValueHelper(v8::Local<v8::Value> arg,
                                  v8::Local<v8::Context> context,
                                  const base::Optional<int>& minimum,
                                  std::unique_ptr<base::Value>* out_value) {
   T val;
   if (!gin::Converter<T>::FromV8(context->GetIsolate(), arg, &val))
     return false;
   if (minimum && val < minimum.value())
     return false;
   if (out_value)
-    *out_value = base::MakeUnique<base::FundamentalValue>(val);
+    *out_value = base::MakeUnique<base::Value>(val);
   return true;
 }
 
 }  // 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_);
@@ skipping 191 matching lines @@
         // TODO(devlin): If base::StringValue ever takes a std::string&&, we
         // could use std::move to construct.
         *out_value = base::MakeUnique<base::StringValue>(s);
       }
       return true;
     }
     case ArgumentType::BOOLEAN: {
       if (!value->IsBoolean())
         return false;
       if (out_value) {
-        *out_value = base::MakeUnique<base::FundamentalValue>(
-            value.As<v8::Boolean>()->Value());
+        *out_value =
+            base::MakeUnique<base::Value>(value.As<v8::Boolean>()->Value());
       }
       return true;
     }
     default:
       NOTREACHED();
   }
   return false;
 }
 
 bool ArgumentSpec::ParseArgumentToObject(
@@ skipping 138 matching lines @@
       return false;
     }
     if (type_ == ArgumentType::BINARY)
       DCHECK_EQ(base::Value::Type::BINARY, converted->GetType());
     *out_value = std::move(converted);
   }
   return true;
 }
 
 }  // namespace extensions