base/values.cc - chromium/src - Git at Google

 // Copyright 2012 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "base/values.h"

 #include <cmath>
 #include <ostream>
 #include <tuple>
 #include <utility>

 #include "base/bit_cast.h"
 #include "base/check.h"
 #include "base/check_op.h"
 #include "base/containers/checked_iterators.h"
 #include "base/containers/cxx20_erase_vector.h"
 #include "base/containers/map_util.h"
 #include "base/cxx20_to_address.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/notreached.h"
 #include "base/ranges/algorithm.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/base_tracing.h"
 #include "base/tracing_buildflags.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 #include "third_party/abseil-cpp/absl/types/variant.h"

 #if BUILDFLAG(ENABLE_BASE_TRACING)
 #include "base/trace_event/memory_usage_estimator.h"  // no-presubmit-check
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)

 namespace base {

 namespace {

 const char* const kTypeNames[] = {"null",   "boolean", "integer",    "double",
                                   "string", "binary",  "dictionary", "list"};
 static_assert(std::size(kTypeNames) ==
                   static_cast<size_t>(Value::Type::LIST) + 1,
               "kTypeNames Has Wrong Size");

 // Helper class to enumerate the path components from a StringPiece
 // without performing heap allocations. Components are simply separated
 // by single dots (e.g. "foo.bar.baz"  -> ["foo", "bar", "baz"]).
 //
 // Usage example:
 //    PathSplitter splitter(some_path);
 //    while (splitter.HasNext()) {
 //       StringPiece component = splitter.Next();
 //       ...
 //    }
 //
 class PathSplitter {
  public:
   explicit PathSplitter(StringPiece path) : path_(path) {}

   bool HasNext() const { return pos_ < path_.size(); }

   StringPiece Next() {
     DCHECK(HasNext());
     size_t start = pos_;
     size_t pos = path_.find('.', start);
     size_t end;
     if (pos == path_.npos) {
       end = path_.size();
       pos_ = end;
     } else {
       end = pos;
       pos_ = pos + 1;
     }
     return path_.substr(start, end - start);
   }

  private:
   StringPiece path_;
   size_t pos_ = 0;
 };

 std::string DebugStringImpl(ValueView value) {
   std::string json;
   JSONWriter::WriteWithOptions(value, JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }

 }  // namespace

 // A helper used to provide templated functions for cloning to Value, and
 // ValueView. This private class is used so the cloning method may have access
 // to the special private constructors in Value, created specifically for
 // cloning.
 class Value::CloningHelper {
  public:
   // This set of overloads are used to unwrap the reference wrappers, which are
   // presented when cloning a ValueView.
   template <typename T>
   static const T& UnwrapReference(std::reference_wrapper<const T> value) {
     return value.get();
   }

   template <typename T>
   static const T& UnwrapReference(const T& value) {
     return value;
   }

   // Returns a new Value object using the contents of the |storage| variant.
   template <typename Storage>
   static Value Clone(const Storage& storage) {
     return absl::visit(
         [](const auto& member) {
           const auto& value = UnwrapReference(member);
           using T = std::decay_t<decltype(value)>;
           if constexpr (std::is_same_v<T, Value::Dict> ||
                         std::is_same_v<T, Value::List>) {
             return Value(value.Clone());
           } else {
             return Value(value);
           }
         },
         storage);
   }
 };

 // static
 Value Value::FromUniquePtrValue(std::unique_ptr<Value> val) {
   return std::move(*val);
 }

 // static
 std::unique_ptr<Value> Value::ToUniquePtrValue(Value val) {
   return std::make_unique<Value>(std::move(val));
 }

 Value::Value() noexcept = default;

 Value::Value(Value&&) noexcept = default;

 Value& Value::operator=(Value&&) noexcept = default;

 Value::Value(Type type) {
   // Initialize with the default value.
   switch (type) {
     case Type::NONE:
       return;

     case Type::BOOLEAN:
       data_.emplace<bool>(false);
       return;
     case Type::INTEGER:
       data_.emplace<int>(0);
       return;
     case Type::DOUBLE:
       data_.emplace<DoubleStorage>(0.0);
       return;
     case Type::STRING:
       data_.emplace<std::string>();
       return;
     case Type::BINARY:
       data_.emplace<BlobStorage>();
       return;
     case Type::DICT:
       data_.emplace<Dict>();
       return;
     case Type::LIST:
       data_.emplace<List>();
       return;
   }

   CHECK(false);
 }

 Value::Value(bool value) : data_(value) {}

 Value::Value(int value) : data_(value) {}

 Value::Value(double value)
     : data_(absl::in_place_type_t<DoubleStorage>(), value) {}

 Value::Value(StringPiece value) : Value(std::string(value)) {}

 Value::Value(StringPiece16 value) : Value(UTF16ToUTF8(value)) {}

 Value::Value(const char* value) : Value(std::string(value)) {}

 Value::Value(const char16_t* value) : Value(UTF16ToUTF8(value)) {}

 Value::Value(std::string&& value) noexcept : data_(std::move(value)) {
   DCHECK(IsStringUTF8AllowingNoncharacters(GetString()));
 }

 Value::Value(const std::vector<char>& value)
     : data_(absl::in_place_type_t<BlobStorage>(), value.begin(), value.end()) {}

 Value::Value(base::span<const uint8_t> value)
     : data_(absl::in_place_type_t<BlobStorage>(), value.size()) {
   // This is 100x faster than using the "range" constructor for a 512k blob:
   // crbug.com/1343636
   ranges::copy(value, absl::get<BlobStorage>(data_).data());
 }

 Value::Value(BlobStorage&& value) noexcept : data_(std::move(value)) {}

 Value::Value(Dict&& value) noexcept : data_(std::move(value)) {}

 Value::Value(List&& value) noexcept : data_(std::move(value)) {}

 Value::Value(absl::monostate) {}

 Value::Value(DoubleStorage storage) : data_(std::move(storage)) {}

 Value::DoubleStorage::DoubleStorage(double v) : v_(bit_cast<decltype(v_)>(v)) {
   if (!std::isfinite(v)) {
     NOTREACHED() << "Non-finite (i.e. NaN or positive/negative infinity) "
                  << "values cannot be represented in JSON";
     v_ = bit_cast<decltype(v_)>(0.0);
   }
 }

 Value Value::Clone() const {
   return CloningHelper::Clone(data_);
 }

 Value::~Value() = default;

 // static
 const char* Value::GetTypeName(Value::Type type) {
   DCHECK_GE(static_cast<int>(type), 0);
   DCHECK_LT(static_cast<size_t>(type), std::size(kTypeNames));
   return kTypeNames[static_cast<size_t>(type)];
 }

 absl::optional<bool> Value::GetIfBool() const {
   return is_bool() ? absl::make_optional(GetBool()) : absl::nullopt;
 }

 absl::optional<int> Value::GetIfInt() const {
   return is_int() ? absl::make_optional(GetInt()) : absl::nullopt;
 }

 absl::optional<double> Value::GetIfDouble() const {
   return (is_int() || is_double()) ? absl::make_optional(GetDouble())
                                    : absl::nullopt;
 }

 const std::string* Value::GetIfString() const {
   return absl::get_if<std::string>(&data_);
 }

 std::string* Value::GetIfString() {
   return absl::get_if<std::string>(&data_);
 }

 const Value::BlobStorage* Value::GetIfBlob() const {
   return absl::get_if<BlobStorage>(&data_);
 }

 const Value::Dict* Value::GetIfDict() const {
   return absl::get_if<Dict>(&data_);
 }

 Value::Dict* Value::GetIfDict() {
   return absl::get_if<Dict>(&data_);
 }

 const Value::List* Value::GetIfList() const {
   return absl::get_if<List>(&data_);
 }

 Value::List* Value::GetIfList() {
   return absl::get_if<List>(&data_);
 }

 bool Value::GetBool() const {
   DCHECK(is_bool());
   return absl::get<bool>(data_);
 }

 int Value::GetInt() const {
   DCHECK(is_int());
   return absl::get<int>(data_);
 }

 double Value::GetDouble() const {
   if (is_double()) {
     return absl::get<DoubleStorage>(data_);
   }
   if (is_int()) {
     return GetInt();
   }
   CHECK(false);
   return 0.0;
 }

 const std::string& Value::GetString() const {
   DCHECK(is_string());
   return absl::get<std::string>(data_);
 }

 std::string& Value::GetString() {
   DCHECK(is_string());
   return absl::get<std::string>(data_);
 }

 const Value::BlobStorage& Value::GetBlob() const {
   DCHECK(is_blob());
   return absl::get<BlobStorage>(data_);
 }

 const Value::Dict& Value::GetDict() const {
   DCHECK(is_dict());
   return absl::get<Dict>(data_);
 }

 Value::Dict& Value::GetDict() {
   DCHECK(is_dict());
   return absl::get<Dict>(data_);
 }

 const Value::List& Value::GetList() const {
   DCHECK(is_list());
   return absl::get<List>(data_);
 }

 Value::List& Value::GetList() {
   DCHECK(is_list());
   return absl::get<List>(data_);
 }

 std::string Value::TakeString() && {
   return std::move(GetString());
 }

 Value::Dict Value::TakeDict() && {
   return std::move(GetDict());
 }

 Value::List Value::TakeList() && {
   return std::move(GetList());
 }

 Value::Dict::Dict() = default;

 Value::Dict::Dict(Dict&&) noexcept = default;

 Value::Dict& Value::Dict::operator=(Dict&&) noexcept = default;

 Value::Dict::~Dict() = default;

 bool Value::Dict::empty() const {
   return storage_.empty();
 }

 size_t Value::Dict::size() const {
   return storage_.size();
 }

 Value::Dict::iterator Value::Dict::begin() {
   return iterator(storage_.begin());
 }

 Value::Dict::const_iterator Value::Dict::begin() const {
   return const_iterator(storage_.begin());
 }

 Value::Dict::const_iterator Value::Dict::cbegin() const {
   return const_iterator(storage_.cbegin());
 }

 Value::Dict::iterator Value::Dict::end() {
   return iterator(storage_.end());
 }

 Value::Dict::const_iterator Value::Dict::end() const {
   return const_iterator(storage_.end());
 }

 Value::Dict::const_iterator Value::Dict::cend() const {
   return const_iterator(storage_.cend());
 }

 bool Value::Dict::contains(base::StringPiece key) const {
   DCHECK(IsStringUTF8AllowingNoncharacters(key));

   return storage_.contains(key);
 }

 void Value::Dict::clear() {
   return storage_.clear();
 }

 Value::Dict::iterator Value::Dict::erase(iterator pos) {
   return iterator(storage_.erase(pos.GetUnderlyingIteratorDoNotUse()));
 }

 Value::Dict::iterator Value::Dict::erase(const_iterator pos) {
   return iterator(storage_.erase(pos.GetUnderlyingIteratorDoNotUse()));
 }

 Value::Dict Value::Dict::Clone() const {
   return Dict(storage_);
 }

 void Value::Dict::Merge(Dict dict) {
   for (const auto [key, value] : dict) {
     if (Dict* nested_dict = value.GetIfDict()) {
       if (Dict* current_dict = FindDict(key)) {
         // If `key` is a nested dictionary in this dictionary and the dictionary
         // being merged, recursively merge the two dictionaries.
         current_dict->Merge(std::move(*nested_dict));
         continue;
       }
     }

     // Otherwise, unconditionally set the value, overwriting any value that may
     // already be associated with the key.
     Set(key, std::move(value));
   }
 }

 const Value* Value::Dict::Find(StringPiece key) const {
   DCHECK(IsStringUTF8AllowingNoncharacters(key));
   return FindPtrOrNull(storage_, key);
 }

 Value* Value::Dict::Find(StringPiece key) {
   return FindPtrOrNull(storage_, key);
 }

 absl::optional<bool> Value::Dict::FindBool(StringPiece key) const {
   const Value* v = Find(key);
   return v ? v->GetIfBool() : absl::nullopt;
 }

 absl::optional<int> Value::Dict::FindInt(StringPiece key) const {
   const Value* v = Find(key);
   return v ? v->GetIfInt() : absl::nullopt;
 }

 absl::optional<double> Value::Dict::FindDouble(StringPiece key) const {
   const Value* v = Find(key);
   return v ? v->GetIfDouble() : absl::nullopt;
 }

 const std::string* Value::Dict::FindString(StringPiece key) const {
   const Value* v = Find(key);
   return v ? v->GetIfString() : nullptr;
 }

 std::string* Value::Dict::FindString(StringPiece key) {
   Value* v = Find(key);
   return v ? v->GetIfString() : nullptr;
 }

 const Value::BlobStorage* Value::Dict::FindBlob(StringPiece key) const {
   const Value* v = Find(key);
   return v ? v->GetIfBlob() : nullptr;
 }

 const Value::Dict* Value::Dict::FindDict(StringPiece key) const {
   const Value* v = Find(key);
   return v ? v->GetIfDict() : nullptr;
 }

 Value::Dict* Value::Dict::FindDict(StringPiece key) {
   Value* v = Find(key);
   return v ? v->GetIfDict() : nullptr;
 }

 const Value::List* Value::Dict::FindList(StringPiece key) const {
   const Value* v = Find(key);
   return v ? v->GetIfList() : nullptr;
 }

 Value::List* Value::Dict::FindList(StringPiece key) {
   Value* v = Find(key);
   return v ? v->GetIfList() : nullptr;
 }

 Value::Dict* Value::Dict::EnsureDict(StringPiece key) {
   Value::Dict* dict = FindDict(key);
   if (dict) {
     return dict;
   }
   return &Set(key, base::Value::Dict())->GetDict();
 }

 Value::List* Value::Dict::EnsureList(StringPiece key) {
   Value::List* list = FindList(key);
   if (list) {
     return list;
   }
   return &Set(key, base::Value::List())->GetList();
 }

 Value* Value::Dict::Set(StringPiece key, Value&& value) & {
   DCHECK(IsStringUTF8AllowingNoncharacters(key));

   auto wrapped_value = std::make_unique<Value>(std::move(value));
   auto* raw_value = wrapped_value.get();
   storage_.insert_or_assign(key, std::move(wrapped_value));
   return raw_value;
 }

 Value* Value::Dict::Set(StringPiece key, bool value) & {
   return Set(key, Value(value));
 }

 Value* Value::Dict::Set(StringPiece key, int value) & {
   return Set(key, Value(value));
 }

 Value* Value::Dict::Set(StringPiece key, double value) & {
   return Set(key, Value(value));
 }

 Value* Value::Dict::Set(StringPiece key, StringPiece value) & {
   return Set(key, Value(value));
 }

 Value* Value::Dict::Set(StringPiece key, StringPiece16 value) & {
   return Set(key, Value(value));
 }

 Value* Value::Dict::Set(StringPiece key, const char* value) & {
   return Set(key, Value(value));
 }

 Value* Value::Dict::Set(StringPiece key, const char16_t* value) & {
   return Set(key, Value(value));
 }

 Value* Value::Dict::Set(StringPiece key, std::string&& value) & {
   return Set(key, Value(std::move(value)));
 }

 Value* Value::Dict::Set(StringPiece key, BlobStorage&& value) & {
   return Set(key, Value(std::move(value)));
 }

 Value* Value::Dict::Set(StringPiece key, Dict&& value) & {
   return Set(key, Value(std::move(value)));
 }

 Value* Value::Dict::Set(StringPiece key, List&& value) & {
   return Set(key, Value(std::move(value)));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, Value&& value) && {
   DCHECK(IsStringUTF8AllowingNoncharacters(key));
   storage_.insert_or_assign(key, std::make_unique<Value>(std::move(value)));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, bool value) && {
   return std::move(*this).Set(key, Value(value));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, int value) && {
   return std::move(*this).Set(key, Value(value));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, double value) && {
   return std::move(*this).Set(key, Value(value));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, StringPiece value) && {
   return std::move(*this).Set(key, Value(value));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, StringPiece16 value) && {
   return std::move(*this).Set(key, Value(value));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, const char* value) && {
   return std::move(*this).Set(key, Value(value));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, const char16_t* value) && {
   return std::move(*this).Set(key, Value(value));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, std::string&& value) && {
   return std::move(*this).Set(key, Value(std::move(value)));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, BlobStorage&& value) && {
   return std::move(*this).Set(key, Value(std::move(value)));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, Dict&& value) && {
   return std::move(*this).Set(key, Value(std::move(value)));
 }

 Value::Dict&& Value::Dict::Set(StringPiece key, List&& value) && {
   return std::move(*this).Set(key, Value(std::move(value)));
 }

 bool Value::Dict::Remove(StringPiece key) {
   DCHECK(IsStringUTF8AllowingNoncharacters(key));

   return storage_.erase(key) > 0;
 }

 absl::optional<Value> Value::Dict::Extract(StringPiece key) {
   DCHECK(IsStringUTF8AllowingNoncharacters(key));

   auto it = storage_.find(key);
   if (it == storage_.end()) {
     return absl::nullopt;
   }
   Value v = std::move(*it->second);
   storage_.erase(it);
   return v;
 }

 const Value* Value::Dict::FindByDottedPath(StringPiece path) const {
   DCHECK(!path.empty());
   DCHECK(IsStringUTF8AllowingNoncharacters(path));

   const Dict* current_dict = this;
   const Value* current_value = nullptr;
   PathSplitter splitter(path);
   while (true) {
     current_value = current_dict->Find(splitter.Next());
     if (!splitter.HasNext()) {
       return current_value;
     }
     if (!current_value) {
       return nullptr;
     }
     current_dict = current_value->GetIfDict();
     if (!current_dict) {
       return nullptr;
     }
   }
 }

 Value* Value::Dict::FindByDottedPath(StringPiece path) {
   return const_cast<Value*>(std::as_const(*this).FindByDottedPath(path));
 }

 absl::optional<bool> Value::Dict::FindBoolByDottedPath(StringPiece path) const {
   const Value* v = FindByDottedPath(path);
   return v ? v->GetIfBool() : absl::nullopt;
 }

 absl::optional<int> Value::Dict::FindIntByDottedPath(StringPiece path) const {
   const Value* v = FindByDottedPath(path);
   return v ? v->GetIfInt() : absl::nullopt;
 }

 absl::optional<double> Value::Dict::FindDoubleByDottedPath(
     StringPiece path) const {
   const Value* v = FindByDottedPath(path);
   return v ? v->GetIfDouble() : absl::nullopt;
 }

 const std::string* Value::Dict::FindStringByDottedPath(StringPiece path) const {
   const Value* v = FindByDottedPath(path);
   return v ? v->GetIfString() : nullptr;
 }

 std::string* Value::Dict::FindStringByDottedPath(StringPiece path) {
   Value* v = FindByDottedPath(path);
   return v ? v->GetIfString() : nullptr;
 }

 const Value::BlobStorage* Value::Dict::FindBlobByDottedPath(
     StringPiece path) const {
   const Value* v = FindByDottedPath(path);
   return v ? v->GetIfBlob() : nullptr;
 }

 const Value::Dict* Value::Dict::FindDictByDottedPath(StringPiece path) const {
   const Value* v = FindByDottedPath(path);
   return v ? v->GetIfDict() : nullptr;
 }

 Value::Dict* Value::Dict::FindDictByDottedPath(StringPiece path) {
   Value* v = FindByDottedPath(path);
   return v ? v->GetIfDict() : nullptr;
 }

 const Value::List* Value::Dict::FindListByDottedPath(StringPiece path) const {
   const Value* v = FindByDottedPath(path);
   return v ? v->GetIfList() : nullptr;
 }

 Value::List* Value::Dict::FindListByDottedPath(StringPiece path) {
   Value* v = FindByDottedPath(path);
   return v ? v->GetIfList() : nullptr;
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, Value&& value) & {
   DCHECK(!path.empty());
   DCHECK(IsStringUTF8AllowingNoncharacters(path));

   Dict* current_dict = this;
   Value* current_value = nullptr;
   PathSplitter splitter(path);
   while (true) {
     StringPiece next_key = splitter.Next();
     if (!splitter.HasNext()) {
       return current_dict->Set(next_key, std::move(value));
     }
     // This could be clever to avoid a double-lookup via use of lower_bound(),
     // but for now, just implement it the most straightforward way.
     current_value = current_dict->Find(next_key);
     if (current_value) {
       // Unlike the legacy DictionaryValue API, encountering an intermediate
       // node that is not a `Value::Type::DICT` is an error.
       current_dict = current_value->GetIfDict();
       if (!current_dict) {
         return nullptr;
       }
     } else {
       current_dict = &current_dict->Set(next_key, Dict())->GetDict();
     }
   }
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, bool value) & {
   return SetByDottedPath(path, Value(value));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, int value) & {
   return SetByDottedPath(path, Value(value));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, double value) & {
   return SetByDottedPath(path, Value(value));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, StringPiece value) & {
   return SetByDottedPath(path, Value(value));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, StringPiece16 value) & {
   return SetByDottedPath(path, Value(value));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, const char* value) & {
   return SetByDottedPath(path, Value(value));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, const char16_t* value) & {
   return SetByDottedPath(path, Value(value));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, std::string&& value) & {
   return SetByDottedPath(path, Value(std::move(value)));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, BlobStorage&& value) & {
   return SetByDottedPath(path, Value(std::move(value)));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, Dict&& value) & {
   return SetByDottedPath(path, Value(std::move(value)));
 }

 Value* Value::Dict::SetByDottedPath(StringPiece path, List&& value) & {
   return SetByDottedPath(path, Value(std::move(value)));
 }

 bool Value::Dict::RemoveByDottedPath(StringPiece path) {
   return ExtractByDottedPath(path).has_value();
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path, Value&& value) && {
   SetByDottedPath(path, std::move(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path, bool value) && {
   SetByDottedPath(path, Value(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path, int value) && {
   SetByDottedPath(path, Value(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path, double value) && {
   SetByDottedPath(path, Value(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path,
                                            StringPiece value) && {
   SetByDottedPath(path, Value(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path,
                                            StringPiece16 value) && {
   SetByDottedPath(path, Value(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path,
                                            const char* value) && {
   SetByDottedPath(path, Value(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path,
                                            const char16_t* value) && {
   SetByDottedPath(path, Value(value));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path,
                                            std::string&& value) && {
   SetByDottedPath(path, Value(std::move(value)));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path,
                                            BlobStorage&& value) && {
   SetByDottedPath(path, Value(std::move(value)));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path, Dict&& value) && {
   SetByDottedPath(path, Value(std::move(value)));
   return std::move(*this);
 }

 Value::Dict&& Value::Dict::SetByDottedPath(StringPiece path, List&& value) && {
   SetByDottedPath(path, Value(std::move(value)));
   return std::move(*this);
 }

 absl::optional<Value> Value::Dict::ExtractByDottedPath(StringPiece path) {
   DCHECK(!path.empty());
   DCHECK(IsStringUTF8AllowingNoncharacters(path));

   // Use recursion instead of PathSplitter here, as it simplifies code for
   // removing dictionaries that become empty if a value matching `path` is
   // extracted.
   size_t dot_index = path.find('.');
   if (dot_index == StringPiece::npos) {
     return Extract(path);
   }
   // This could be clever to avoid a double-lookup by using storage_ directly,
   // but for now, just implement it in the most straightforward way.
   StringPiece next_key = path.substr(0, dot_index);
   auto* next_dict = FindDict(next_key);
   if (!next_dict) {
     return absl::nullopt;
   }
   absl::optional<Value> extracted =
       next_dict->ExtractByDottedPath(path.substr(dot_index + 1));
   if (extracted && next_dict->empty()) {
     Remove(next_key);
   }
   return extracted;
 }

 size_t Value::Dict::EstimateMemoryUsage() const {
 #if BUILDFLAG(ENABLE_BASE_TRACING)
   return base::trace_event::EstimateMemoryUsage(storage_);
 #else   // BUILDFLAG(ENABLE_BASE_TRACING)
   return 0;
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
 }

 std::string Value::Dict::DebugString() const {
   return DebugStringImpl(*this);
 }

 #if BUILDFLAG(ENABLE_BASE_TRACING)
 void Value::Dict::WriteIntoTrace(perfetto::TracedValue context) const {
   perfetto::TracedDictionary dict = std::move(context).WriteDictionary();
   for (auto kv : *this) {
     dict.Add(perfetto::DynamicString(kv.first), kv.second);
   }
 }
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)

 Value::Dict::Dict(
     const flat_map<std::string, std::unique_ptr<Value>>& storage) {
   storage_.reserve(storage.size());
   for (const auto& [key, value] : storage) {
     Set(key, value->Clone());
   }
 }

 bool operator==(const Value::Dict& lhs, const Value::Dict& rhs) {
   auto deref_2nd = [](const auto& p) { return std::tie(p.first, *p.second); };
   return ranges::equal(lhs.storage_, rhs.storage_, {}, deref_2nd, deref_2nd);
 }

 bool operator!=(const Value::Dict& lhs, const Value::Dict& rhs) {
   return !(lhs == rhs);
 }

 bool operator<(const Value::Dict& lhs, const Value::Dict& rhs) {
   auto deref_2nd = [](const auto& p) { return std::tie(p.first, *p.second); };
   return ranges::lexicographical_compare(lhs.storage_, rhs.storage_, {},
                                          deref_2nd, deref_2nd);
 }

 bool operator>(const Value::Dict& lhs, const Value::Dict& rhs) {
   return rhs < lhs;
 }

 bool operator<=(const Value::Dict& lhs, const Value::Dict& rhs) {
   return !(rhs < lhs);
 }

 bool operator>=(const Value::Dict& lhs, const Value::Dict& rhs) {
   return !(lhs < rhs);
 }

 // static
 Value::List Value::List::with_capacity(size_t capacity) {
   Value::List result;
   result.reserve(capacity);
   return result;
 }

 Value::List::List() = default;

 Value::List::List(List&&) noexcept = default;

 Value::List& Value::List::operator=(List&&) noexcept = default;

 Value::List::~List() = default;

 bool Value::List::empty() const {
   return storage_.empty();
 }

 size_t Value::List::size() const {
   return storage_.size();
 }

 Value::List::iterator Value::List::begin() {
   return iterator(base::to_address(storage_.begin()),
                   base::to_address(storage_.end()));
 }

 Value::List::const_iterator Value::List::begin() const {
   return const_iterator(base::to_address(storage_.begin()),
                         base::to_address(storage_.end()));
 }

 Value::List::const_iterator Value::List::cbegin() const {
   return const_iterator(base::to_address(storage_.cbegin()),
                         base::to_address(storage_.cend()));
 }

 Value::List::iterator Value::List::end() {
   return iterator(base::to_address(storage_.begin()),
                   base::to_address(storage_.end()),
                   base::to_address(storage_.end()));
 }

 Value::List::const_iterator Value::List::end() const {
   return const_iterator(base::to_address(storage_.begin()),
                         base::to_address(storage_.end()),
                         base::to_address(storage_.end()));
 }

 Value::List::const_iterator Value::List::cend() const {
   return const_iterator(base::to_address(storage_.cbegin()),
                         base::to_address(storage_.cend()),
                         base::to_address(storage_.cend()));
 }

 Value::List::reverse_iterator Value::List::rend() {
   return reverse_iterator(begin());
 }

 Value::List::const_reverse_iterator Value::List::rend() const {
   return const_reverse_iterator(begin());
 }

 Value::List::reverse_iterator Value::List::rbegin() {
   return reverse_iterator(end());
 }

 Value::List::const_reverse_iterator Value::List::rbegin() const {
   return const_reverse_iterator(end());
 }

 const Value& Value::List::front() const {
   CHECK(!storage_.empty());
   return storage_.front();
 }

 Value& Value::List::front() {
   CHECK(!storage_.empty());
   return storage_.front();
 }

 const Value& Value::List::back() const {
   CHECK(!storage_.empty());
   return storage_.back();
 }

 Value& Value::List::back() {
   CHECK(!storage_.empty());
   return storage_.back();
 }

 void Value::List::reserve(size_t capacity) {
   storage_.reserve(capacity);
 }

 void Value::List::resize(size_t new_size) {
   storage_.resize(new_size);
 }

 const Value& Value::List::operator[](size_t index) const {
   CHECK_LT(index, storage_.size());
   return storage_[index];
 }

 Value& Value::List::operator[](size_t index) {
   CHECK_LT(index, storage_.size());
   return storage_[index];
 }

 void Value::List::clear() {
   storage_.clear();
 }

 Value::List::iterator Value::List::erase(iterator pos) {
   auto next_it = storage_.erase(storage_.begin() + (pos - begin()));
   return iterator(base::to_address(storage_.begin()), base::to_address(next_it),
                   base::to_address(storage_.end()));
 }

 Value::List::const_iterator Value::List::erase(const_iterator pos) {
   auto next_it = storage_.erase(storage_.begin() + (pos - begin()));
   return const_iterator(base::to_address(storage_.begin()),
                         base::to_address(next_it),
                         base::to_address(storage_.end()));
 }

 Value::List::iterator Value::List::erase(iterator first, iterator last) {
   auto next_it = storage_.erase(storage_.begin() + (first - begin()),
                                 storage_.begin() + (last - begin()));
   return iterator(base::to_address(storage_.begin()), base::to_address(next_it),
                   base::to_address(storage_.end()));
 }

 Value::List::const_iterator Value::List::erase(const_iterator first,
                                                const_iterator last) {
   auto next_it = storage_.erase(storage_.begin() + (first - begin()),
                                 storage_.begin() + (last - begin()));
   return const_iterator(base::to_address(storage_.begin()),
                         base::to_address(next_it),
                         base::to_address(storage_.end()));
 }

 Value::List Value::List::Clone() const {
   return List(storage_);
 }

 void Value::List::Append(Value&& value) & {
   storage_.emplace_back(std::move(value));
 }

 void Value::List::Append(bool value) & {
   storage_.emplace_back(value);
 }

 void Value::List::Append(int value) & {
   storage_.emplace_back(value);
 }

 void Value::List::Append(double value) & {
   storage_.emplace_back(value);
 }

 void Value::List::Append(StringPiece value) & {
   Append(Value(value));
 }

 void Value::List::Append(StringPiece16 value) & {
   storage_.emplace_back(value);
 }

 void Value::List::Append(const char* value) & {
   storage_.emplace_back(value);
 }

 void Value::List::Append(const char16_t* value) & {
   storage_.emplace_back(value);
 }

 void Value::List::Append(std::string&& value) & {
   storage_.emplace_back(std::move(value));
 }

 void Value::List::Append(BlobStorage&& value) & {
   storage_.emplace_back(std::move(value));
 }

 void Value::List::Append(Dict&& value) & {
   storage_.emplace_back(std::move(value));
 }

 void Value::List::Append(List&& value) & {
   storage_.emplace_back(std::move(value));
 }

 Value::List&& Value::List::Append(Value&& value) && {
   storage_.emplace_back(std::move(value));
   return std::move(*this);
 }

 Value::List&& Value::List::Append(bool value) && {
   storage_.emplace_back(value);
   return std::move(*this);
 }

 Value::List&& Value::List::Append(int value) && {
   storage_.emplace_back(value);
   return std::move(*this);
 }

 Value::List&& Value::List::Append(double value) && {
   storage_.emplace_back(value);
   return std::move(*this);
 }

 Value::List&& Value::List::Append(StringPiece value) && {
   Append(Value(value));
   return std::move(*this);
 }

 Value::List&& Value::List::Append(StringPiece16 value) && {
   storage_.emplace_back(value);
   return std::move(*this);
 }

 Value::List&& Value::List::Append(const char* value) && {
   storage_.emplace_back(value);
   return std::move(*this);
 }

 Value::List&& Value::List::Append(const char16_t* value) && {
   storage_.emplace_back(value);
   return std::move(*this);
 }

 Value::List&& Value::List::Append(std::string&& value) && {
   storage_.emplace_back(std::move(value));
   return std::move(*this);
 }

 Value::List&& Value::List::Append(BlobStorage&& value) && {
   storage_.emplace_back(std::move(value));
   return std::move(*this);
 }

 Value::List&& Value::List::Append(Dict&& value) && {
   storage_.emplace_back(std::move(value));
   return std::move(*this);
 }

 Value::List&& Value::List::Append(List&& value) && {
   storage_.emplace_back(std::move(value));
   return std::move(*this);
 }

 Value::List::iterator Value::List::Insert(const_iterator pos, Value&& value) {
   auto inserted_it =
       storage_.insert(storage_.begin() + (pos - begin()), std::move(value));
   return iterator(base::to_address(storage_.begin()),
                   base::to_address(inserted_it),
                   base::to_address(storage_.end()));
 }

 size_t Value::List::EraseValue(const Value& value) {
   return Erase(storage_, value);
 }

 size_t Value::List::EstimateMemoryUsage() const {
 #if BUILDFLAG(ENABLE_BASE_TRACING)
   return base::trace_event::EstimateMemoryUsage(storage_);
 #else   // BUILDFLAG(ENABLE_BASE_TRACING)
   return 0;
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
 }

 std::string Value::List::DebugString() const {
   return DebugStringImpl(*this);
 }

 #if BUILDFLAG(ENABLE_BASE_TRACING)
 void Value::List::WriteIntoTrace(perfetto::TracedValue context) const {
   perfetto::TracedArray array = std::move(context).WriteArray();
   for (const auto& item : *this) {
     array.Append(item);
   }
 }
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)

 Value::List::List(const std::vector<Value>& storage) {
   storage_.reserve(storage.size());
   for (const auto& value : storage) {
     storage_.push_back(value.Clone());
   }
 }

 bool operator==(const Value::List& lhs, const Value::List& rhs) {
   return lhs.storage_ == rhs.storage_;
 }

 bool operator!=(const Value::List& lhs, const Value::List& rhs) {
   return !(lhs == rhs);
 }

 bool operator<(const Value::List& lhs, const Value::List& rhs) {
   return lhs.storage_ < rhs.storage_;
 }

 bool operator>(const Value::List& lhs, const Value::List& rhs) {
   return rhs < lhs;
 }

 bool operator<=(const Value::List& lhs, const Value::List& rhs) {
   return !(rhs < lhs);
 }

 bool operator>=(const Value::List& lhs, const Value::List& rhs) {
   return !(lhs < rhs);
 }

 bool operator==(const Value& lhs, const Value& rhs) {
   return lhs.data_ == rhs.data_;
 }

 bool operator!=(const Value& lhs, const Value& rhs) {
   return !(lhs == rhs);
 }

 bool operator<(const Value& lhs, const Value& rhs) {
   return lhs.data_ < rhs.data_;
 }

 bool operator>(const Value& lhs, const Value& rhs) {
   return rhs < lhs;
 }

 bool operator<=(const Value& lhs, const Value& rhs) {
   return !(rhs < lhs);
 }

 bool operator>=(const Value& lhs, const Value& rhs) {
   return !(lhs < rhs);
 }

 bool operator==(const Value& lhs, bool rhs) {
   return lhs.is_bool() && lhs.GetBool() == rhs;
 }

 bool operator==(const Value& lhs, int rhs) {
   return lhs.is_int() && lhs.GetInt() == rhs;
 }

 bool operator==(const Value& lhs, double rhs) {
   return lhs.is_double() && lhs.GetDouble() == rhs;
 }

 bool operator==(const Value& lhs, StringPiece rhs) {
   return lhs.is_string() && lhs.GetString() == rhs;
 }

 bool operator==(const Value& lhs, const Value::Dict& rhs) {
   return lhs.is_dict() && lhs.GetDict() == rhs;
 }

 bool operator==(const Value& lhs, const Value::List& rhs) {
   return lhs.is_list() && lhs.GetList() == rhs;
 }

 size_t Value::EstimateMemoryUsage() const {
   switch (type()) {
 #if BUILDFLAG(ENABLE_BASE_TRACING)
     case Type::STRING:
       return base::trace_event::EstimateMemoryUsage(GetString());
     case Type::BINARY:
       return base::trace_event::EstimateMemoryUsage(GetBlob());
     case Type::DICT:
       return GetDict().EstimateMemoryUsage();
     case Type::LIST:
       return GetList().EstimateMemoryUsage();
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
     default:
       return 0;
   }
 }

 std::string Value::DebugString() const {
   return DebugStringImpl(*this);
 }

 #if BUILDFLAG(ENABLE_BASE_TRACING)
 void Value::WriteIntoTrace(perfetto::TracedValue context) const {
   Visit([&](const auto& member) {
     using T = std::decay_t<decltype(member)>;
     if constexpr (std::is_same_v<T, absl::monostate>) {
       std::move(context).WriteString("<none>");
     } else if constexpr (std::is_same_v<T, bool>) {
       std::move(context).WriteBoolean(member);
     } else if constexpr (std::is_same_v<T, int>) {
       std::move(context).WriteInt64(member);
     } else if constexpr (std::is_same_v<T, DoubleStorage>) {
       std::move(context).WriteDouble(member);
     } else if constexpr (std::is_same_v<T, std::string>) {
       std::move(context).WriteString(member);
     } else if constexpr (std::is_same_v<T, BlobStorage>) {
       std::move(context).WriteString("<binary data not supported>");
     } else if constexpr (std::is_same_v<T, Dict>) {
       member.WriteIntoTrace(std::move(context));
     } else if constexpr (std::is_same_v<T, List>) {
       member.WriteIntoTrace(std::move(context));
     }
   });
 }
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)

 ValueView::ValueView(const Value& value)
     : data_view_(
           value.Visit([](const auto& member) { return ViewType(member); })) {}

 Value ValueView::ToValue() const {
   return Value::CloningHelper::Clone(data_view_);
 }

 ValueSerializer::~ValueSerializer() = default;

 ValueDeserializer::~ValueDeserializer() = default;

 std::ostream& operator<<(std::ostream& out, const Value& value) {
   return out << value.DebugString();
 }

 std::ostream& operator<<(std::ostream& out, const Value::Dict& dict) {
   return out << dict.DebugString();
 }

 std::ostream& operator<<(std::ostream& out, const Value::List& list) {
   return out << list.DebugString();
 }

 std::ostream& operator<<(std::ostream& out, const Value::Type& type) {
   if (static_cast<int>(type) < 0 ||
       static_cast<size_t>(type) >= std::size(kTypeNames)) {
     return out << "Invalid Type (index = " << static_cast<int>(type) << ")";
   }
   return out << Value::GetTypeName(type);
 }

 }  // namespace base