From be59a35641616a4cf23c4a13fa0632624b021c1b Mon Sep 17 00:00:00 2001 From: Allan Sandfeld Jensen Date: Mon, 20 Nov 2017 10:33:36 +0100 Subject: BASELINE: Update Chromium to 62.0.3202.101 Change-Id: I2d5eca8117600df6d331f6166ab24d943d9814ac Reviewed-by: Alexandru Croitor --- chromium/base/values.cc | 371 ++++++++++++++++++++---------------------------- 1 file changed, 155 insertions(+), 216 deletions(-) (limited to 'chromium/base/values.cc') diff --git a/chromium/base/values.cc b/chromium/base/values.cc index 37a4e944363..723ad6f9c28 100644 --- a/chromium/base/values.cc +++ b/chromium/base/values.cc @@ -39,7 +39,8 @@ std::unique_ptr CopyListWithoutEmptyChildren(const Value& list) { if (child_copy) copy.GetList().push_back(std::move(*child_copy)); } - return copy.GetList().empty() ? nullptr : MakeUnique(std::move(copy)); + return copy.GetList().empty() ? nullptr + : std::make_unique(std::move(copy)); } std::unique_ptr CopyDictionaryWithoutEmptyChildren( @@ -49,7 +50,7 @@ std::unique_ptr CopyDictionaryWithoutEmptyChildren( std::unique_ptr child_copy = CopyWithoutEmptyChildren(it.value()); if (child_copy) { if (!copy) - copy = MakeUnique(); + copy = std::make_unique(); copy->SetWithoutPathExpansion(it.key(), std::move(child_copy)); } } @@ -66,7 +67,7 @@ std::unique_ptr CopyWithoutEmptyChildren(const Value& node) { static_cast(node)); default: - return MakeUnique(node); + return std::make_unique(node.Clone()); } } @@ -75,11 +76,7 @@ std::unique_ptr CopyWithoutEmptyChildren(const Value& node) { // static std::unique_ptr Value::CreateWithCopiedBuffer(const char* buffer, size_t size) { - return MakeUnique(BlobStorage(buffer, buffer + size)); -} - -Value::Value(const Value& that) { - InternalCopyConstructFrom(that); + return std::make_unique(BlobStorage(buffer, buffer + size)); } Value::Value(Value&& that) noexcept { @@ -163,30 +160,30 @@ Value::Value(BlobStorage&& in_blob) noexcept : type_(Type::BINARY) { binary_value_.Init(std::move(in_blob)); } +Value::Value(const DictStorage& in_dict) : type_(Type::DICTIONARY) { + dict_.Init(); + dict_->reserve(in_dict.size()); + for (const auto& it : in_dict) { + dict_->emplace_hint(dict_->end(), it.first, + MakeUnique(it.second->Clone())); + } +} + Value::Value(DictStorage&& in_dict) noexcept : type_(Type::DICTIONARY) { dict_.Init(std::move(in_dict)); } Value::Value(const ListStorage& in_list) : type_(Type::LIST) { - list_.Init(in_list); + list_.Init(); + list_->reserve(in_list.size()); + for (const auto& val : in_list) + list_->emplace_back(val.Clone()); } Value::Value(ListStorage&& in_list) noexcept : type_(Type::LIST) { list_.Init(std::move(in_list)); } -Value& Value::operator=(const Value& that) { - if (type_ == that.type_) { - InternalCopyAssignFromSameType(that); - } else { - // This is not a self assignment because the type_ doesn't match. - InternalCleanup(); - InternalCopyConstructFrom(that); - } - - return *this; -} - Value& Value::operator=(Value&& that) noexcept { InternalCleanup(); InternalMoveConstructFrom(std::move(that)); @@ -194,6 +191,30 @@ Value& Value::operator=(Value&& that) noexcept { return *this; } +Value Value::Clone() const { + switch (type_) { + case Type::NONE: + return Value(); + case Type::BOOLEAN: + return Value(bool_value_); + case Type::INTEGER: + return Value(int_value_); + case Type::DOUBLE: + return Value(double_value_); + case Type::STRING: + return Value(*string_value_); + case Type::BINARY: + return Value(*binary_value_); + case Type::DICTIONARY: + return Value(*dict_); + case Type::LIST: + return Value(*list_); + } + + NOTREACHED(); + return Value(); +} + Value::~Value() { InternalCleanup(); } @@ -244,87 +265,124 @@ const Value::ListStorage& Value::GetList() const { return *list_; } -Value::dict_iterator Value::FindKey(const char* key) { - return FindKey(std::string(key)); +Value* Value::FindKey(StringPiece key) { + return const_cast(static_cast(this)->FindKey(key)); } -Value::dict_iterator Value::FindKey(const std::string& key) { +const Value* Value::FindKey(StringPiece key) const { CHECK(is_dict()); - return dict_iterator(dict_->find(key)); + auto found = dict_->find(key); + if (found == dict_->end()) + return nullptr; + return found->second.get(); } -Value::const_dict_iterator Value::FindKey(const char* key) const { - return FindKey(std::string(key)); +Value* Value::FindKeyOfType(StringPiece key, Type type) { + return const_cast( + static_cast(this)->FindKeyOfType(key, type)); } -Value::const_dict_iterator Value::FindKey(const std::string& key) const { - CHECK(is_dict()); - return const_dict_iterator(dict_->find(key)); +const Value* Value::FindKeyOfType(StringPiece key, Type type) const { + const Value* result = FindKey(key); + if (!result || result->type() != type) + return nullptr; + return result; } -Value::dict_iterator Value::FindKeyOfType(const char* key, Type type) { - return FindKeyOfType(std::string(key), type); +Value* Value::SetKey(StringPiece key, Value value) { + CHECK(is_dict()); + return ((*dict_)[key.as_string()] = std::make_unique(std::move(value))) + .get(); } -Value::dict_iterator Value::FindKeyOfType(const std::string& key, Type type) { +Value* Value::SetKey(std::string&& key, Value value) { CHECK(is_dict()); - auto iter = dict_->find(key); - return dict_iterator((iter != dict_->end() && iter->second->IsType(type)) - ? iter - : dict_->end()); + return ((*dict_)[std::move(key)] = std::make_unique(std::move(value))) + .get(); } -Value::const_dict_iterator Value::FindKeyOfType(const char* key, - Type type) const { - return FindKeyOfType(std::string(key), type); +Value* Value::SetKey(const char* key, Value value) { + return SetKey(StringPiece(key), std::move(value)); } -Value::const_dict_iterator Value::FindKeyOfType(const std::string& key, - Type type) const { - CHECK(is_dict()); - auto iter = dict_->find(key); - return const_dict_iterator( - (iter != dict_->end() && iter->second->IsType(type)) ? iter - : dict_->end()); +Value* Value::FindPath(std::initializer_list path) { + return const_cast(const_cast(this)->FindPath(path)); } -Value::dict_iterator Value::SetKey(const char* key, Value value) { - return SetKey(std::string(key), std::move(value)); +Value* Value::FindPath(span path) { + return const_cast(const_cast(this)->FindPath(path)); } -Value::dict_iterator Value::SetKey(const std::string& key, Value value) { - CHECK(is_dict()); - auto iter = dict_->find(key); - if (iter != dict_->end()) { - *iter->second = std::move(value); - return dict_iterator(iter); +const Value* Value::FindPath(std::initializer_list path) const { + return FindPath(make_span(path.begin(), path.size())); +} + +const Value* Value::FindPath(span path) const { + const Value* cur = this; + for (const StringPiece component : path) { + if (!cur->is_dict() || (cur = cur->FindKey(component)) == nullptr) + return nullptr; } + return cur; +} - return dict_iterator( - dict_->emplace(key, MakeUnique(std::move(value))).first); +Value* Value::FindPathOfType(std::initializer_list path, + Type type) { + return const_cast( + const_cast(this)->FindPathOfType(path, type)); } -Value::dict_iterator Value::SetKey(std::string&& key, Value value) { - CHECK(is_dict()); - auto iter = dict_->find(key); - if (iter != dict_->end()) { - *iter->second = std::move(value); - return dict_iterator(iter); - } +Value* Value::FindPathOfType(span path, Type type) { + return const_cast( + const_cast(this)->FindPathOfType(path, type)); +} - return dict_iterator( - dict_->emplace(std::move(key), MakeUnique(std::move(value))) - .first); +const Value* Value::FindPathOfType(std::initializer_list path, + Type type) const { + return FindPathOfType(make_span(path.begin(), path.size()), type); } -Value::dict_iterator Value::DictEnd() { - CHECK(is_dict()); - return dict_iterator(dict_->end()); +const Value* Value::FindPathOfType(span path, + Type type) const { + const Value* result = FindPath(path); + if (!result || !result->IsType(type)) + return nullptr; + return result; } -Value::const_dict_iterator Value::DictEnd() const { - CHECK(is_dict()); - return const_dict_iterator(dict_->end()); +Value* Value::SetPath(std::initializer_list path, Value value) { + return SetPath(make_span(path.begin(), path.size()), std::move(value)); +} + +Value* Value::SetPath(span path, Value value) { + DCHECK_NE(path.begin(), path.end()); // Can't be empty path. + + // Walk/construct intermediate dictionaries. The last element requires + // special handling so skip it in this loop. + Value* cur = this; + const StringPiece* cur_path = path.begin(); + for (; (cur_path + 1) < path.end(); ++cur_path) { + if (!cur->is_dict()) + return nullptr; + + // Use lower_bound to avoid doing the search twice for missing keys. + const StringPiece path_component = *cur_path; + auto found = cur->dict_->lower_bound(path_component); + if (found == cur->dict_->end() || found->first != path_component) { + // No key found, insert one. + auto inserted = + cur->dict_->emplace_hint(found, path_component.as_string(), + std::make_unique(Type::DICTIONARY)); + cur = inserted->second.get(); + } else { + cur = found->second.get(); + } + } + + // "cur" will now contain the last dictionary to insert or replace into. + if (!cur->is_dict()) + return nullptr; + return cur->SetKey(*cur_path, std::move(value)); } Value::dict_iterator_proxy Value::DictItems() { @@ -430,11 +488,11 @@ bool Value::GetAsDictionary(const DictionaryValue** out_value) const { } Value* Value::DeepCopy() const { - return new Value(*this); + return new Value(Clone()); } std::unique_ptr Value::CreateDeepCopy() const { - return MakeUnique(*this); + return std::make_unique(Clone()); } bool operator==(const Value& lhs, const Value& rhs) { @@ -530,21 +588,12 @@ bool Value::Equals(const Value* other) const { return *this == *other; } -// static -bool Value::Equals(const Value* a, const Value* b) { - if ((a == NULL) && (b == NULL)) - return true; - if ((a == NULL) ^ (b == NULL)) - return false; - return *a == *b; -} +void Value::InternalMoveConstructFrom(Value&& that) { + type_ = that.type_; -void Value::InternalCopyFundamentalValue(const Value& that) { switch (type_) { case Type::NONE: - // Nothing to do. return; - case Type::BOOLEAN: bool_value_ = that.bool_value_; return; @@ -554,57 +603,6 @@ void Value::InternalCopyFundamentalValue(const Value& that) { case Type::DOUBLE: double_value_ = that.double_value_; return; - - default: - NOTREACHED(); - } -} - -void Value::InternalCopyConstructFrom(const Value& that) { - type_ = that.type_; - - switch (type_) { - case Type::NONE: - case Type::BOOLEAN: - case Type::INTEGER: - case Type::DOUBLE: - InternalCopyFundamentalValue(that); - return; - - case Type::STRING: - string_value_.Init(*that.string_value_); - return; - case Type::BINARY: - binary_value_.Init(*that.binary_value_); - return; - // DictStorage is a move-only type due to the presence of unique_ptrs. This - // is why the explicit copy of every element is necessary here. - // TODO(crbug.com/646113): Clean this up when DictStorage can be copied - // directly. - case Type::DICTIONARY: - dict_.Init(); - for (const auto& it : *that.dict_) { - dict_->emplace_hint(dict_->end(), it.first, - MakeUnique(*it.second)); - } - return; - case Type::LIST: - list_.Init(*that.list_); - return; - } -} - -void Value::InternalMoveConstructFrom(Value&& that) { - type_ = that.type_; - - switch (type_) { - case Type::NONE: - case Type::BOOLEAN: - case Type::INTEGER: - case Type::DOUBLE: - InternalCopyFundamentalValue(that); - return; - case Type::STRING: string_value_.InitFromMove(std::move(that.string_value_)); return; @@ -620,40 +618,6 @@ void Value::InternalMoveConstructFrom(Value&& that) { } } -void Value::InternalCopyAssignFromSameType(const Value& that) { - // TODO(crbug.com/646113): make this a DCHECK once base::Value does not have - // subclasses. - CHECK_EQ(type_, that.type_); - - switch (type_) { - case Type::NONE: - case Type::BOOLEAN: - case Type::INTEGER: - case Type::DOUBLE: - InternalCopyFundamentalValue(that); - return; - - case Type::STRING: - *string_value_ = *that.string_value_; - return; - case Type::BINARY: - *binary_value_ = *that.binary_value_; - return; - // DictStorage is a move-only type due to the presence of unique_ptrs. This - // is why the explicit call to the copy constructor is necessary here. - // TODO(crbug.com/646113): Clean this up when DictStorage can be copied - // directly. - case Type::DICTIONARY: { - Value copy = that; - *dict_ = std::move(*copy.dict_); - return; - } - case Type::LIST: - *list_ = *that.list_; - return; - } -} - void Value::InternalCleanup() { switch (type_) { case Type::NONE: @@ -692,10 +656,13 @@ std::unique_ptr DictionaryValue::From( } DictionaryValue::DictionaryValue() : Value(Type::DICTIONARY) {} +DictionaryValue::DictionaryValue(const DictStorage& in_dict) : Value(in_dict) {} +DictionaryValue::DictionaryValue(DictStorage&& in_dict) noexcept + : Value(std::move(in_dict)) {} bool DictionaryValue::HasKey(StringPiece key) const { DCHECK(IsStringUTF8(key)); - auto current_entry = dict_->find(key.as_string()); + auto current_entry = dict_->find(key); DCHECK((current_entry == dict_->end()) || current_entry->second); return current_entry != dict_->end(); } @@ -718,7 +685,7 @@ Value* DictionaryValue::Set(StringPiece path, std::unique_ptr in_value) { DictionaryValue* child_dictionary = nullptr; if (!current_dictionary->GetDictionary(key, &child_dictionary)) { child_dictionary = current_dictionary->SetDictionaryWithoutPathExpansion( - key, MakeUnique()); + key, std::make_unique()); } current_dictionary = child_dictionary; @@ -730,23 +697,23 @@ Value* DictionaryValue::Set(StringPiece path, std::unique_ptr in_value) { } Value* DictionaryValue::SetBoolean(StringPiece path, bool in_value) { - return Set(path, MakeUnique(in_value)); + return Set(path, std::make_unique(in_value)); } Value* DictionaryValue::SetInteger(StringPiece path, int in_value) { - return Set(path, MakeUnique(in_value)); + return Set(path, std::make_unique(in_value)); } Value* DictionaryValue::SetDouble(StringPiece path, double in_value) { - return Set(path, MakeUnique(in_value)); + return Set(path, std::make_unique(in_value)); } Value* DictionaryValue::SetString(StringPiece path, StringPiece in_value) { - return Set(path, MakeUnique(in_value)); + return Set(path, std::make_unique(in_value)); } Value* DictionaryValue::SetString(StringPiece path, const string16& in_value) { - return Set(path, MakeUnique(in_value)); + return Set(path, std::make_unique(in_value)); } DictionaryValue* DictionaryValue::SetDictionary( @@ -766,32 +733,6 @@ Value* DictionaryValue::SetWithoutPathExpansion( return ((*dict_)[key.as_string()] = std::move(in_value)).get(); } -Value* DictionaryValue::SetBooleanWithoutPathExpansion(StringPiece path, - bool in_value) { - return SetWithoutPathExpansion(path, MakeUnique(in_value)); -} - -Value* DictionaryValue::SetIntegerWithoutPathExpansion(StringPiece path, - int in_value) { - return SetWithoutPathExpansion(path, MakeUnique(in_value)); -} - -Value* DictionaryValue::SetDoubleWithoutPathExpansion(StringPiece path, - double in_value) { - return SetWithoutPathExpansion(path, MakeUnique(in_value)); -} - -Value* DictionaryValue::SetStringWithoutPathExpansion(StringPiece path, - StringPiece in_value) { - return SetWithoutPathExpansion(path, MakeUnique(in_value)); -} - -Value* DictionaryValue::SetStringWithoutPathExpansion( - StringPiece path, - const string16& in_value) { - return SetWithoutPathExpansion(path, MakeUnique(in_value)); -} - DictionaryValue* DictionaryValue::SetDictionaryWithoutPathExpansion( StringPiece path, std::unique_ptr in_value) { @@ -949,7 +890,7 @@ bool DictionaryValue::GetList(StringPiece path, ListValue** out_value) { bool DictionaryValue::GetWithoutPathExpansion(StringPiece key, const Value** out_value) const { DCHECK(IsStringUTF8(key)); - auto entry_iterator = dict_->find(key.as_string()); + auto entry_iterator = dict_->find(key); if (entry_iterator == dict_->end()) return false; @@ -1078,7 +1019,7 @@ bool DictionaryValue::RemoveWithoutPathExpansion( StringPiece key, std::unique_ptr* out_value) { DCHECK(IsStringUTF8(key)); - auto entry_iterator = dict_->find(key.as_string()); + auto entry_iterator = dict_->find(key); if (entry_iterator == dict_->end()) return false; @@ -1113,7 +1054,7 @@ std::unique_ptr DictionaryValue::DeepCopyWithoutEmptyChildren() std::unique_ptr copy = CopyDictionaryWithoutEmptyChildren(*this); if (!copy) - copy = MakeUnique(); + copy = std::make_unique(); return copy; } @@ -1131,7 +1072,7 @@ void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) { } } // All other cases: Make a copy and hook it up. - SetWithoutPathExpansion(it.key(), MakeUnique(*merge_value)); + SetKey(it.key(), merge_value->Clone()); } } @@ -1148,11 +1089,11 @@ DictionaryValue::Iterator::Iterator(const Iterator& other) = default; DictionaryValue::Iterator::~Iterator() {} DictionaryValue* DictionaryValue::DeepCopy() const { - return new DictionaryValue(*this); + return new DictionaryValue(*dict_); } std::unique_ptr DictionaryValue::CreateDeepCopy() const { - return MakeUnique(*this); + return std::make_unique(*dict_); } ///////////////////// ListValue //////////////////// @@ -1168,9 +1109,7 @@ std::unique_ptr ListValue::From(std::unique_ptr value) { } ListValue::ListValue() : Value(Type::LIST) {} - ListValue::ListValue(const ListStorage& in_list) : Value(in_list) {} - ListValue::ListValue(ListStorage&& in_list) noexcept : Value(std::move(in_list)) {} @@ -1308,7 +1247,7 @@ bool ListValue::Remove(size_t index, std::unique_ptr* out_value) { return false; if (out_value) - *out_value = MakeUnique(std::move((*list_)[index])); + *out_value = std::make_unique(std::move((*list_)[index])); list_->erase(list_->begin() + index); return true; @@ -1330,7 +1269,7 @@ bool ListValue::Remove(const Value& value, size_t* index) { ListValue::iterator ListValue::Erase(iterator iter, std::unique_ptr* out_value) { if (out_value) - *out_value = MakeUnique(std::move(*iter)); + *out_value = std::make_unique(std::move(*iter)); return list_->erase(iter); } @@ -1399,11 +1338,11 @@ void ListValue::Swap(ListValue* other) { } ListValue* ListValue::DeepCopy() const { - return new ListValue(*this); + return new ListValue(*list_); } std::unique_ptr ListValue::CreateDeepCopy() const { - return MakeUnique(*this); + return std::make_unique(*list_); } ValueSerializer::~ValueSerializer() { -- cgit v1.2.3