Change base::Value::ListStorage to std::vector<base::Value>

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 17 matching lines @@
               "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> child_copy = CopyWithoutEmptyChildren(*entry);
+    std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(entry);
     if (child_copy) {
       if (!copy)
         copy.reset(new ListValue);
       copy->Append(std::move(child_copy));
     }
   }
   return copy;
 }
 
 std::unique_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
@@ skipping 116 matching lines @@
 Value::Value(StringPiece in_string) : Value(in_string.as_string()) {}
 
 Value::Value(const std::vector<char>& in_blob) : type_(Type::BINARY) {
   binary_value_.Init(in_blob);
 }
 
 Value::Value(std::vector<char>&& in_blob) : type_(Type::BINARY) {
   binary_value_.Init(std::move(in_blob));
 }
 
+Value::Value(const ListStorage& in_list) : type_(Type::LIST) {
+  list_.Init(in_list);
+}
+
+Value::Value(ListStorage&& in_list) : type_(Type::LIST) {
+  list_.Init(std::move(in_list));
+}
+
 Value& Value::operator=(const Value& that) {
   if (this != &that) {
     if (type_ == that.type_) {
       InternalCopyAssignFromSameType(that);
     } else {
       InternalCleanup();
       InternalCopyConstructFrom(that);
     }
   }
 
@@ skipping 188 matching lines @@
       DictionaryValue* result = new DictionaryValue;
 
       for (const auto& current_entry : **dict_ptr_) {
         result->SetWithoutPathExpansion(current_entry.first,
                                         current_entry.second->CreateDeepCopy());
       }
 
       return result;
     }
 
-    case Type::LIST: {
-      ListValue* result = new ListValue;
-
-      for (const auto& entry : *list_)
-        result->Append(entry->CreateDeepCopy());
-
-      return result;
-    }
+    case Type::LIST:
+      return new Value(*list_);
 
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 std::unique_ptr<Value> Value::CreateDeepCopy() const {
   return WrapUnique(DeepCopy());
 }
@@ skipping 28 matching lines @@
                           if (lhs.first != rhs.first)
                             return false;
 
                           return lhs.second->Equals(rhs.second.get());
                         });
     }
     case Type::LIST: {
       if (list_->size() != other->list_->size())
         return false;
 
-      return std::equal(std::begin(*list_), std::end(*list_),
-                        std::begin(*(other->list_)),
-                        [](const ListStorage::value_type& lhs,
-                           const ListStorage::value_type& rhs) {
-                          return lhs->Equals(rhs.get());
-                        });
+      return std::equal(
+          std::begin(*list_), std::end(*list_), std::begin(*(other->list_)),
+          [](const ListStorage::value_type& lhs,
+             const ListStorage::value_type& rhs) { return lhs.Equals(&rhs); });
     }
   }
 
   NOTREACHED();
   return false;
 }
 
 // static
 bool Value::Equals(const Value* a, const Value* b) {
   if ((a == NULL) && (b == NULL)) return true;
@@ skipping 32 matching lines @@
     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 and ListStorage are move-only types due to the presence of
-    // unique_ptrs. This is why the call to |CreateDeepCopy| is necessary here.
-    // TODO(crbug.com/646113): Clean this up when DictStorage and ListStorage
-    // can be copied directly.
+    // DictStorage is a move-only type due to the presence of unique_ptrs. This
+    // is why the call to |CreateDeepCopy| is necessary here.
+    // TODO(crbug.com/646113): Clean this up when DictStorage can be copied
+    // directly.
     case Type::DICTIONARY:
       dict_ptr_.Init(std::move(*that.CreateDeepCopy()->dict_ptr_));

[brettw, 2017/03/17 05:39:19]

I suspect this line is causing the Android crash. CreateDeepCopy creates a
temporary unique_ptr, we get the dict_ptr out of that, but then the unique_ptr
is destroyed and we pass a dangling pointer to std::move.

Try making a named unique_ptr<Value> to hold the deep copy on the previous line
and see if that makes the problem go away.

[jdoerrie, 2017/03/23 18:11:17]

Unfortunately this didn't solve the issue. After more fruitless printf debugging
I am now trying (and currently still failing) to get the test running with an
ASAN build. This will hopefully make the issue obvious.

       return;
     case Type::LIST:
-      list_.Init(std::move(*that.CreateDeepCopy()->list_));
+      list_.Init(*that.list_);
       return;
   }
 }
 
 void Value::InternalMoveConstructFrom(Value&& that) {
   type_ = that.type_;
 
   switch (type_) {
     case Type::NONE:
     case Type::BOOLEAN:
@@ skipping 27 matching lines @@
     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 and ListStorage are move-only types due to the presence of
-    // unique_ptrs. This is why the call to |CreateDeepCopy| is necessary here.
-    // TODO(crbug.com/646113): Clean this up when DictStorage and ListStorage
-    // can be copied directly.
+    // DictStorage is a move-only type due to the presence of unique_ptrs. This
+    // is why the call to |CreateDeepCopy| is necessary here.
+    // TODO(crbug.com/646113): Clean this up when DictStorage can be copied
+    // directly.
     case Type::DICTIONARY:
       *dict_ptr_ = std::move(*that.CreateDeepCopy()->dict_ptr_);

[brettw, 2017/03/17 05:39:19]

Ditto here.

       return;
     case Type::LIST:
-      *list_ = std::move(*that.CreateDeepCopy()->list_);
+      *list_ = *that.list_;
       return;
   }
 }
 
 void Value::InternalMoveAssignFromSameType(Value&& that) {
   CHECK_EQ(type_, that.type_);
 
   switch (type_) {
     case Type::NONE:
     case Type::BOOLEAN:
@@ skipping 516 matching lines @@
   }
   return nullptr;
 }
 
 ListValue::ListValue() : Value(Type::LIST) {}
 
 void ListValue::Clear() {
   list_->clear();
 }
 
+void ListValue::Reserve(size_t n) {
+  list_->reserve(n);
+}
+
 bool ListValue::Set(size_t index, Value* in_value) {
   return Set(index, WrapUnique(in_value));
 }
 
 bool ListValue::Set(size_t index, std::unique_ptr<Value> in_value) {
   if (!in_value)
     return false;
 
   if (index >= list_->size()) {
     // Pad out any intermediate indexes with null settings
     while (index > list_->size())
       Append(CreateNullValue());
     Append(std::move(in_value));
   } else {
-    // TODO(dcheng): remove this DCHECK once the raw pointer version is removed?
-    DCHECK((*list_)[index] != in_value);
-    (*list_)[index] = std::move(in_value);
+    (*list_)[index] = std::move(*in_value);
   }
   return true;
 }
 
 bool ListValue::Get(size_t index, const Value** out_value) const {
   if (index >= list_->size())
     return false;
 
   if (out_value)
-    *out_value = (*list_)[index].get();
+    *out_value = &(*list_)[index];
 
   return true;
 }
 
 bool ListValue::Get(size_t index, Value** out_value) {
   return static_cast<const ListValue&>(*this).Get(
       index,
       const_cast<const Value**>(out_value));
 }
 
@@ skipping 90 matching lines @@
   return static_cast<const ListValue&>(*this).GetList(
       index,
       const_cast<const ListValue**>(out_value));
 }
 
 bool ListValue::Remove(size_t index, std::unique_ptr<Value>* out_value) {
   if (index >= list_->size())
     return false;
 
   if (out_value)
-    *out_value = std::move((*list_)[index]);
+    *out_value = MakeUnique<Value>(std::move((*list_)[index]));
 
   list_->erase(list_->begin() + index);
   return true;
 }
 
 bool ListValue::Remove(const Value& value, size_t* index) {
-  for (auto it = list_->begin(); it != list_->end(); ++it) {
-    if ((*it)->Equals(&value)) {
-      size_t previous_index = it - list_->begin();
-      list_->erase(it);
+  auto it = std::find_if(
+      list_->begin(), list_->end(),
+      [&value](const Value& entry) { return entry.Equals(&value); });
 
-      if (index)
-        *index = previous_index;
-      return true;
-    }
-  }
-  return false;
+  if (it == list_->end())
+    return false;
+
+  if (index)
+    *index = std::distance(list_->begin(), it);
+
+  list_->erase(it);
+  return true;
 }
 
 ListValue::iterator ListValue::Erase(iterator iter,
                                      std::unique_ptr<Value>* out_value) {
   if (out_value)
-    *out_value = std::move(*ListStorage::iterator(iter));
+    *out_value = MakeUnique<Value>(std::move(*iter));
 
   return list_->erase(iter);
 }
 
 void ListValue::Append(std::unique_ptr<Value> in_value) {
-  list_->push_back(std::move(in_value));
+  list_->push_back(std::move(*in_value));
 }
 
 #if !defined(OS_LINUX)
 void ListValue::Append(Value* in_value) {
   DCHECK(in_value);
   Append(WrapUnique(in_value));
 }
 #endif
 
 void ListValue::AppendBoolean(bool in_value) {
@@ skipping 26 matching lines @@
 void ListValue::AppendStrings(const std::vector<string16>& in_values) {
   for (std::vector<string16>::const_iterator it = in_values.begin();
        it != in_values.end(); ++it) {
     AppendString(*it);
   }
 }
 
 bool ListValue::AppendIfNotPresent(std::unique_ptr<Value> in_value) {
   DCHECK(in_value);
   for (const auto& entry : *list_) {
-    if (entry->Equals(in_value.get())) {
+    if (entry.Equals(in_value.get())) {
       return false;
     }
   }
-  list_->push_back(std::move(in_value));
+  list_->push_back(std::move(*in_value));
   return true;
 }
 
 bool ListValue::Insert(size_t index, std::unique_ptr<Value> in_value) {
   DCHECK(in_value);
   if (index > list_->size())
     return false;
 
-  list_->insert(list_->begin() + index, std::move(in_value));
+  list_->insert(list_->begin() + index, std::move(*in_value));
   return true;
 }
 
 ListValue::const_iterator ListValue::Find(const Value& value) const {
-  return std::find_if(list_->begin(), list_->end(),
-                      [&value](const std::unique_ptr<Value>& entry) {
-                        return entry->Equals(&value);
-                      });
+  return std::find_if(
+      list_->begin(), list_->end(),
+      [&value](const Value& entry) { return entry.Equals(&value); });
 }
 
 void ListValue::Swap(ListValue* other) {
   CHECK(other->is_list());
   list_->swap(*(other->list_));
 }
 
 ListValue* ListValue::DeepCopy() const {
   return static_cast<ListValue*>(Value::DeepCopy());
 }
@@ skipping 15 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