Convert //dbus from scoped_ptr to std::unique_ptr

dbus/property_unittest.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/property.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 140 matching lines @@
   // the method call is made that identifies it and distinguishes from any
   // other; you can set this to whatever you wish.
   void WaitForCallback(const std::string& id) {
     while (last_callback_ != id) {
       run_loop_.reset(new base::RunLoop);
       run_loop_->Run();
     }
   }
 
   base::MessageLoop message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
-  scoped_ptr<base::Thread> dbus_thread_;
+  std::unique_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::Thread> dbus_thread_;
   scoped_refptr<Bus> bus_;
   ObjectProxy* object_proxy_;
-  scoped_ptr<Properties> properties_;
-  scoped_ptr<TestService> test_service_;
+  std::unique_ptr<Properties> properties_;
+  std::unique_ptr<TestService> test_service_;
   // Properties updated.
   std::vector<std::string> updated_properties_;
   // Last callback received.
   std::string last_callback_;
 };
 
 TEST_F(PropertyTest, InitialValues) {
   EXPECT_FALSE(properties_->name.is_valid());
   EXPECT_FALSE(properties_->version.is_valid());
 
@@ skipping 144 matching lines @@
                                    base::Unretained(this), "Set"));
   WaitForCallback("Set");
 
   // TestService sends a property update.
   WaitForUpdates(1);
 
   EXPECT_TRUE(properties_->name.is_valid());
 }
 
 TEST(PropertyTestStatic, ReadWriteStringMap) {
-  scoped_ptr<Response> message(Response::CreateEmpty());
+  std::unique_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   MessageWriter variant_writer(NULL);
   MessageWriter variant_array_writer(NULL);
   MessageWriter struct_entry_writer(NULL);
 
   writer.OpenVariant("a{ss}", &variant_writer);
   variant_writer.OpenArray("{ss}", &variant_array_writer);
   const char* items[] = {"One", "Two", "Three", "Four"};
   for (unsigned i = 0; i < arraysize(items); ++i) {
     variant_array_writer.OpenDictEntry(&struct_entry_writer);
@@ skipping 13 matching lines @@
   EXPECT_EQ("3", string_map.value().at("Three"));
   EXPECT_EQ("4", string_map.value().at("Four"));
 }
 
 TEST(PropertyTestStatic, SerializeStringMap) {
   std::map<std::string, std::string> test_map;
   test_map["Hi"] = "There";
   test_map["Map"] = "Test";
   test_map["Random"] = "Text";
 
-  scoped_ptr<Response> message(Response::CreateEmpty());
+  std::unique_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
 
   Property<std::map<std::string, std::string>> string_map;
   string_map.ReplaceSetValueForTesting(test_map);
   string_map.AppendSetValueToWriter(&writer);
 
   MessageReader reader(message.get());
   EXPECT_TRUE(string_map.PopValueFromReader(&reader));
   EXPECT_EQ(test_map, string_map.value());
 }
 
 TEST(PropertyTestStatic, ReadWriteNetAddressArray) {
-  scoped_ptr<Response> message(Response::CreateEmpty());
+  std::unique_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   MessageWriter variant_writer(NULL);
   MessageWriter variant_array_writer(NULL);
   MessageWriter struct_entry_writer(NULL);
 
   writer.OpenVariant("a(ayq)", &variant_writer);
   variant_writer.OpenArray("(ayq)", &variant_array_writer);
   uint8_t ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30};
   for (uint16_t i = 0; i < 5; ++i) {
     variant_array_writer.OpenStruct(&struct_entry_writer);
@@ skipping 23 matching lines @@
 TEST(PropertyTestStatic, SerializeNetAddressArray) {
   std::vector<std::pair<std::vector<uint8_t>, uint16_t>> test_list;
 
   uint8_t ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30};
   for (uint16_t i = 0; i < 5; ++i) {
     ip_bytes[4] = 0x30 + i;
     std::vector<uint8_t> bytes(ip_bytes, ip_bytes + arraysize(ip_bytes));
     test_list.push_back(make_pair(bytes, 16));
   }
 
-  scoped_ptr<Response> message(Response::CreateEmpty());
+  std::unique_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
 
   Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>> ip_list;
   ip_list.ReplaceSetValueForTesting(test_list);
   ip_list.AppendSetValueToWriter(&writer);
 
   MessageReader reader(message.get());
   EXPECT_TRUE(ip_list.PopValueFromReader(&reader));
   EXPECT_EQ(test_list, ip_list.value());
 }
 
 }  // namespace dbus