Convert //base to use std::unique_ptr

base/json/json_value_converter.h

 // 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.
 
 #ifndef BASE_JSON_JSON_VALUE_CONVERTER_H_
 #define BASE_JSON_JSON_VALUE_CONVERTER_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 
 // JSONValueConverter converts a JSON value into a C++ struct in a
 // lightweight way.
 //
 // Usage:
@@ skipping 97 matching lines @@
         field_pointer_(field),
         value_converter_(converter) {
   }
 
   bool ConvertField(const base::Value& value, StructType* dst) const override {
     return value_converter_->Convert(value, &(dst->*field_pointer_));
   }
 
  private:
   FieldType StructType::* field_pointer_;
-  scoped_ptr<ValueConverter<FieldType> > value_converter_;
+  std::unique_ptr<ValueConverter<FieldType>> value_converter_;
   DISALLOW_COPY_AND_ASSIGN(FieldConverter);
 };
 
 template <typename FieldType>
 class BasicValueConverter;
 
 template <>
 class BASE_EXPORT BasicValueConverter<int> : public ValueConverter<int> {
  public:
   BasicValueConverter() {}
@@ skipping 114 matching lines @@
       // The field is not a list.
       return false;
     }
 
     field->reserve(list->GetSize());
     for (size_t i = 0; i < list->GetSize(); ++i) {
       const base::Value* element = NULL;
       if (!list->Get(i, &element))
         continue;
 
-      scoped_ptr<Element> e(new Element);
+      std::unique_ptr<Element> e(new Element);
       if (basic_converter_.Convert(*element, e.get())) {
         field->push_back(e.release());
       } else {
         DVLOG(1) << "failure at " << i << "-th element";
         return false;
       }
     }
     return true;
   }
 
@@ skipping 13 matching lines @@
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list))
       return false;
 
     field->reserve(list->GetSize());
     for (size_t i = 0; i < list->GetSize(); ++i) {
       const base::Value* element = NULL;
       if (!list->Get(i, &element))
         continue;
 
-      scoped_ptr<NestedType> nested(new NestedType);
+      std::unique_ptr<NestedType> nested(new NestedType);
       if (converter_.Convert(*element, nested.get())) {
         field->push_back(nested.release());
       } else {
         DVLOG(1) << "failure at " << i << "-th element";
         return false;
       }
     }
     return true;
   }
 
@@ skipping 16 matching lines @@
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list))
       return false;
 
     field->reserve(list->GetSize());
     for (size_t i = 0; i < list->GetSize(); ++i) {
       const base::Value* element = NULL;
       if (!list->Get(i, &element))
         continue;
 
-      scoped_ptr<NestedType> nested(new NestedType);
+      std::unique_ptr<NestedType> nested(new NestedType);
       if ((*convert_func_)(element, nested.get())) {
         field->push_back(nested.release());
       } else {
         DVLOG(1) << "failure at " << i << "-th element";
         return false;
       }
     }
     return true;
   }
 
@@ skipping 156 matching lines @@
 
  private:
   ScopedVector<internal::FieldConverterBase<StructType> > fields_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONValueConverter);
 };
 
 }  // namespace base
 
 #endif  // BASE_JSON_JSON_VALUE_CONVERTER_H_