Remove base::ListValue::Set(size_t, base::Value*)

ipc/ipc_message_utils.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 "ipc/ipc_message_utils.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/unguessable_token.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_message_attachment.h"
 #include "ipc/ipc_message_attachment_set.h"
@@ skipping 42 matching lines @@
   if (data.size() > kMaxBytesToLog) {
     out->append(base::StringPrintf(
         " and %u more bytes",
         static_cast<unsigned>(data.size() - kMaxBytesToLog)));
   }
 #endif
 }
 
 bool ReadValue(const base::Pickle* m,
                base::PickleIterator* iter,
-               base::Value** value,
+               std::unique_ptr<base::Value>* value,
                int recursion);
 
 void GetValueSize(base::PickleSizer* sizer,
                   const base::Value* value,
                   int recursion) {
   if (recursion > kMaxRecursionDepth) {
     LOG(ERROR) << "Max recursion depth hit in GetValueSize.";
     return;
   }
 
@@ skipping 126 matching lines @@
 bool ReadDictionaryValue(const base::Pickle* m,
                          base::PickleIterator* iter,
                          base::DictionaryValue* value,
                          int recursion) {
   int size;
   if (!ReadParam(m, iter, &size))
     return false;
 
   for (int i = 0; i < size; ++i) {
     std::string key;
-    base::Value* subval;
+    std::unique_ptr<base::Value> subval;
     if (!ReadParam(m, iter, &key) ||
         !ReadValue(m, iter, &subval, recursion + 1))
       return false;
-    value->SetWithoutPathExpansion(key, subval);
+    value->SetWithoutPathExpansion(key, std::move(subval));
   }
 
   return true;
 }
 
 // Helper for ReadValue that reads a ReadListValue into a pre-allocated
 // object.
 bool ReadListValue(const base::Pickle* m,
                    base::PickleIterator* iter,
                    base::ListValue* value,
                    int recursion) {
   int size;
   if (!ReadParam(m, iter, &size))
     return false;
 
   for (int i = 0; i < size; ++i) {
-    base::Value* subval;
+    std::unique_ptr<base::Value> subval;
     if (!ReadValue(m, iter, &subval, recursion + 1))
       return false;
-    value->Set(i, subval);
+    value->Set(i, std::move(subval));
   }
 
   return true;
 }
 
 bool ReadValue(const base::Pickle* m,
                base::PickleIterator* iter,
-               base::Value** value,
+               std::unique_ptr<base::Value>* value,
                int recursion) {
   if (recursion > kMaxRecursionDepth) {
     LOG(ERROR) << "Max recursion depth hit in ReadValue.";
     return false;
   }
 
   int type;
   if (!ReadParam(m, iter, &type))
     return false;
 
   switch (static_cast<base::Value::Type>(type)) {
     case base::Value::Type::NONE:
-      *value = new base::Value();
+      *value = base::MakeUnique<base::Value>();
       break;
     case base::Value::Type::BOOLEAN: {
       bool val;
       if (!ReadParam(m, iter, &val))
         return false;
-      *value = new base::Value(val);
+      *value = base::MakeUnique<base::Value>(val);
       break;
     }
     case base::Value::Type::INTEGER: {
       int val;
       if (!ReadParam(m, iter, &val))
         return false;
-      *value = new base::Value(val);
+      *value = base::MakeUnique<base::Value>(val);
       break;
     }
     case base::Value::Type::DOUBLE: {
       double val;
       if (!ReadParam(m, iter, &val))
         return false;
-      *value = new base::Value(val);
+      *value = base::MakeUnique<base::Value>(val);
       break;
     }
     case base::Value::Type::STRING: {
       std::string val;
       if (!ReadParam(m, iter, &val))
         return false;
-      *value = new base::Value(val);
+      *value = base::MakeUnique<base::Value>(std::move(val));
       break;
     }
     case base::Value::Type::BINARY: {
       const char* data;
       int length;
       if (!iter->ReadData(&data, &length))
         return false;
-      std::unique_ptr<base::Value> val =
-          base::Value::CreateWithCopiedBuffer(data, length);
-      *value = val.release();
+      *value = base::Value::CreateWithCopiedBuffer(data, length);
       break;
     }
     case base::Value::Type::DICTIONARY: {
-      std::unique_ptr<base::DictionaryValue> val(new base::DictionaryValue());
-      if (!ReadDictionaryValue(m, iter, val.get(), recursion))
+      base::DictionaryValue val;
+      if (!ReadDictionaryValue(m, iter, &val, recursion))
         return false;
-      *value = val.release();
+      *value = base::MakeUnique<base::Value>(std::move(val));
       break;
     }
     case base::Value::Type::LIST: {
-      std::unique_ptr<base::ListValue> val(new base::ListValue());
-      if (!ReadListValue(m, iter, val.get(), recursion))
+      base::ListValue val;
+      if (!ReadListValue(m, iter, &val, recursion))
         return false;
-      *value = val.release();
+      *value = base::MakeUnique<base::Value>(std::move(val));
       break;
     }
     default:
     return false;
   }
 
   return true;
 }
 
 }  // namespace
@@ skipping 902 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC