Remove FundamentalValue

base/values.h

 // 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.
 
 // This file specifies a recursive data storage class called Value intended for
 // storing settings and other persistable data.
 //
 // A Value represents something that can be stored in JSON or passed to/from
 // JavaScript. As such, it is NOT a generalized variant type, since only the
 // types supported by JavaScript/JSON are supported.
@@ skipping 19 matching lines @@
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 
 namespace base {
 
 class BinaryValue;
 class DictionaryValue;
-class FundamentalValue;
 class ListValue;
 class StringValue;
 class Value;
 
 // The Value class is the base class for Values. A Value can be instantiated
 // via the Create*Value() factory methods, or by directly creating instances of
 // the subclasses.
 //
 // See the file-level comment above for more information.
 class BASE_EXPORT Value {
  public:
   enum Type {
     TYPE_NULL = 0,
     TYPE_BOOLEAN,
     TYPE_INTEGER,
     TYPE_DOUBLE,
     TYPE_STRING,
     TYPE_BINARY,
     TYPE_DICTIONARY,
     TYPE_LIST
     // Note: Do not add more types. See the file-level comment above for why.
   };
 
   Value();  // A null value.
+  Value(bool in_bool);
+  Value(int in_int);
+  Value(double in_double);
 
   virtual ~Value();
 
   static std::unique_ptr<Value> CreateNullValue();
 
   // Returns the name for a given |type|.
   static const char* GetTypeName(Type type);
 
   // Returns the type of the value stored by the current Value object.
   // Each type will be implemented by only one subclass of Value, so it's
@@ skipping 52 matching lines @@
   // Compares if two Value objects have equal contents. Can handle NULLs.
   // NULLs are considered equal but different from Value::CreateNullValue().
   static bool Equals(const Value* a, const Value* b);
 
  protected:
   // These aren't safe for end-users, but they are useful for subclasses.
   explicit Value(Type type);
   Value(const Value& that);
   Value& operator=(const Value& that);
 
-  // TODO(brettw) move to public when FundamentalValue is gone.
-  Value(bool in_bool);
-  Value(int in_int);
-  Value(double in_double);
-
  private:
   Type type_;
 
   union {
     bool bool_value_;
     int int_value_;
     double double_value_;
   };
 };
 
-// FundamentalValue represents the simple fundamental types of values.
-// TODO(brettw) remove when callers are updated to use raw Value.
-class BASE_EXPORT FundamentalValue : public Value {
- public:
-  explicit FundamentalValue(bool in_value);
-  explicit FundamentalValue(int in_value);
-  explicit FundamentalValue(double in_value);
-  ~FundamentalValue() override;
-};
-
 class BASE_EXPORT StringValue : public Value {
  public:
   // Initializes a StringValue with a UTF-8 narrow character string.
   explicit StringValue(StringPiece in_value);
 
   // Initializes a StringValue with a string16.
   explicit StringValue(const string16& in_value);
 
   ~StringValue() override;
 
@@ skipping 375 matching lines @@
                                              std::string* error_str) = 0;
 };
 
 // Stream operator so Values can be used in assertion statements.  In order that
 // gtest uses this operator to print readable output on test failures, we must
 // override each specific type. Otherwise, the default template implementation
 // is preferred over an upcast.
 BASE_EXPORT std::ostream& operator<<(std::ostream& out, const Value& value);
 
 BASE_EXPORT inline std::ostream& operator<<(std::ostream& out,
-                                            const FundamentalValue& value) {
-  return out << static_cast<const Value&>(value);
-}
-
-BASE_EXPORT inline std::ostream& operator<<(std::ostream& out,
                                             const StringValue& value) {
   return out << static_cast<const Value&>(value);
 }
 
 BASE_EXPORT inline std::ostream& operator<<(std::ostream& out,
                                             const DictionaryValue& value) {
   return out << static_cast<const Value&>(value);
 }
 
 BASE_EXPORT inline std::ostream& operator<<(std::ostream& out,
                                             const ListValue& value) {
   return out << static_cast<const Value&>(value);
 }
 
 }  // namespace base
 
 #endif  // BASE_VALUES_H_