Convert //dbus from scoped_ptr to std::unique_ptr

dbus/values_util.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 "dbus/values_util.h"
 
+#include <memory>
+
 #include "base/json/json_writer.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "dbus/message.h"
 
 namespace dbus {
 
 namespace {
 
 // Returns whether |value| is exactly representable by double or not.
 template<typename T>
 bool IsExactlyRepresentableByDouble(T value) {
@@ skipping 20 matching lines @@
     if (!reader->PopDictEntry(&entry_reader))
       return false;
     // Get key as a string.
     std::string key_string;
     if (entry_reader.GetDataType() == Message::STRING) {
       // If the type of keys is STRING, pop it directly.
       if (!entry_reader.PopString(&key_string))
         return false;
     } else {
       // If the type of keys is not STRING, convert it to string.
-      scoped_ptr<base::Value> key(PopDataAsValue(&entry_reader));
+      std::unique_ptr<base::Value> key(PopDataAsValue(&entry_reader));
       if (!key)
         return false;
       // Use JSONWriter to convert an arbitrary value to a string.
       base::JSONWriter::Write(*key, &key_string);
     }
     // Get the value and set the key-value pair.
     base::Value* value = PopDataAsValue(&entry_reader);
     if (!value)
       return false;
     dictionary_value->SetWithoutPathExpansion(key_string, value);
@@ skipping 108 matching lines @@
       // Cannot distinguish a file descriptor from an int
       NOTREACHED();
       break;
     }
     case Message::ARRAY: {
       MessageReader sub_reader(NULL);
       if (reader->PopArray(&sub_reader)) {
         // If the type of the array's element is DICT_ENTRY, create a
         // DictionaryValue, otherwise create a ListValue.
         if (sub_reader.GetDataType() == Message::DICT_ENTRY) {
-          scoped_ptr<base::DictionaryValue> dictionary_value(
+          std::unique_ptr<base::DictionaryValue> dictionary_value(
               new base::DictionaryValue);
           if (PopDictionaryEntries(&sub_reader, dictionary_value.get()))
             result = dictionary_value.release();
         } else {
-          scoped_ptr<base::ListValue> list_value(new base::ListValue);
+          std::unique_ptr<base::ListValue> list_value(new base::ListValue);
           if (PopListElements(&sub_reader, list_value.get()))
             result = list_value.release();
         }
       }
       break;
     }
     case Message::STRUCT: {
       MessageReader sub_reader(NULL);
       if (reader->PopStruct(&sub_reader)) {
-        scoped_ptr<base::ListValue> list_value(new base::ListValue);
+        std::unique_ptr<base::ListValue> list_value(new base::ListValue);
         if (PopListElements(&sub_reader, list_value.get()))
           result = list_value.release();
       }
       break;
     }
     case Message::DICT_ENTRY:
       // DICT_ENTRY must be popped as an element of an array.
       NOTREACHED();
       break;
     case Message::VARIANT: {
@@ skipping 93 matching lines @@
 }
 
 void AppendValueDataAsVariant(MessageWriter* writer, const base::Value& value) {
   MessageWriter variant_writer(NULL);
   writer->OpenVariant(GetTypeSignature(value), &variant_writer);
   AppendValueData(&variant_writer, value);
   writer->CloseContainer(&variant_writer);
 }
 
 }  // namespace dbus