Introduce Value::GetList and Value(ListStorage)

base/values.cc

 // 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.
 
 #include "base/values.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 14 matching lines @@
                                   "string", "binary",  "dictionary", "list"};
 static_assert(arraysize(kTypeNames) ==
                   static_cast<size_t>(Value::Type::LIST) + 1,
               "kTypeNames Has Wrong Size");
 
 std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node);
 
 // Make a deep copy of |node|, but don't include empty lists or dictionaries
 // in the copy. It's possible for this function to return NULL and it
 // expects |node| to always be non-NULL.
-std::unique_ptr<ListValue> CopyListWithoutEmptyChildren(const ListValue& list) {
-  std::unique_ptr<ListValue> copy;
-  for (const auto& entry : list) {
+std::unique_ptr<Value> CopyListWithoutEmptyChildren(const Value& list) {
+  Value copy(Value::Type::LIST);
+  for (const auto& entry : list.GetList()) {
     std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(entry);
-    if (child_copy) {
-      if (!copy)
-        copy.reset(new ListValue);
-      copy->Append(std::move(child_copy));
-    }
+    if (child_copy)
+      copy.GetList().push_back(std::move(*child_copy));
   }
-  return copy;
+  return copy.GetList().empty() ? nullptr : MakeUnique<Value>(std::move(copy));
 }
 
 std::unique_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
     const DictionaryValue& dict) {
   std::unique_ptr<DictionaryValue> copy;
   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
     if (child_copy) {
       if (!copy)
         copy.reset(new DictionaryValue);
@@ skipping 107 matching lines @@
 }
 
 Value::Value(BlobStorage&& in_blob) noexcept : type_(Type::BINARY) {
   binary_value_.Init(std::move(in_blob));
 }
 
 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);
+}
+
+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;
@@ skipping 39 matching lines @@
 const std::string& Value::GetString() const {
   CHECK(is_string());
   return *string_value_;
 }
 
 const Value::BlobStorage& Value::GetBlob() const {
   CHECK(is_blob());
   return *binary_value_;
 }
 
+Value::ListStorage& Value::GetList() {
+  CHECK(is_list());
+  return *list_;
+}
+
+const Value::ListStorage& Value::GetList() const {
+  CHECK(is_list());
+  return *list_;
+}
+
 size_t Value::GetSize() const {
   return GetBlob().size();
 }
 
 const char* Value::GetBuffer() const {
   return GetBlob().data();
 }
 
 bool Value::GetAsBoolean(bool* out_value) const {
   if (out_value && is_bool()) {
@@ skipping 1067 matching lines @@
 }
 
 std::ostream& operator<<(std::ostream& out, const Value::Type& type) {
   if (static_cast<int>(type) < 0 ||
       static_cast<size_t>(type) >= arraysize(kTypeNames))
     return out << "Invalid Type (index = " << static_cast<int>(type) << ")";
   return out << Value::GetTypeName(type);
 }
 
 }  // namespace base