Convert //sync from scoped_ptr to std::unique_ptr

sync/syncable/directory_unittest.cc

 // Copyright 2014 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 "sync/syncable/directory_unittest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
@@ skipping 182 matching lines @@
 }
 
 bool SyncableDirectoryTest::IsInDirtyMetahandles(int64_t metahandle) {
   return 1 == dir_->kernel()->dirty_metahandles.count(metahandle);
 }
 
 bool SyncableDirectoryTest::IsInMetahandlesToPurge(int64_t metahandle) {
   return 1 == dir_->kernel()->metahandles_to_purge.count(metahandle);
 }
 
-scoped_ptr<Directory>& SyncableDirectoryTest::dir() {
+std::unique_ptr<Directory>& SyncableDirectoryTest::dir() {
   return dir_;
 }
 
 DirectoryChangeDelegate* SyncableDirectoryTest::directory_change_delegate() {
   return &delegate_;
 }
 
 Encryptor* SyncableDirectoryTest::encryptor() {
   return &encryptor_;
 }
@@ skipping 1407 matching lines @@
   }
 }
 
 TEST_F(SyncableDirectoryTest, ToValue) {
   const Id id = TestIdFactory::FromNumber(99);
   {
     ReadTransaction rtrans(FROM_HERE, dir().get());
     Entry e(&rtrans, GET_BY_ID, id);
     EXPECT_FALSE(e.good());  // Hasn't been written yet.
 
-    scoped_ptr<base::DictionaryValue> value(e.ToValue(NULL));
+    std::unique_ptr<base::DictionaryValue> value(e.ToValue(NULL));
     ExpectDictBooleanValue(false, *value, "good");
     EXPECT_EQ(1u, value->size());
   }
 
   // Test creating a new meta entry.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir().get());
     MutableEntry me(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "new");
     ASSERT_TRUE(me.good());
     me.PutId(id);
     me.PutBaseVersion(1);
 
-    scoped_ptr<base::DictionaryValue> value(me.ToValue(NULL));
+    std::unique_ptr<base::DictionaryValue> value(me.ToValue(NULL));
     ExpectDictBooleanValue(true, *value, "good");
     EXPECT_TRUE(value->HasKey("kernel"));
     ExpectDictStringValue("Bookmarks", *value, "modelType");
     ExpectDictBooleanValue(true, *value, "existsOnClientBecauseNameIsNonEmpty");
     ExpectDictBooleanValue(false, *value, "isRoot");
   }
 
   dir()->SaveChanges();
 }
 
@@ skipping 37 matching lines @@
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(StressTransactionsDelegate);
 };
 
 // Stress test Directory by accessing it from several threads concurrently.
 TEST_F(SyncableDirectoryTest, StressTransactions) {
   const int kThreadCount = 7;
   base::PlatformThreadHandle threads[kThreadCount];
-  scoped_ptr<StressTransactionsDelegate> thread_delegates[kThreadCount];
+  std::unique_ptr<StressTransactionsDelegate> thread_delegates[kThreadCount];
 
   for (int i = 0; i < kThreadCount; ++i) {
     thread_delegates[i].reset(new StressTransactionsDelegate(dir().get(), i));
     ASSERT_TRUE(base::PlatformThread::Create(
         0, thread_delegates[i].get(), &threads[i]));
   }
 
   for (int i = 0; i < kThreadCount; ++i) {
     base::PlatformThread::Join(threads[i]);
   }
@@ skipping 418 matching lines @@
   EXPECT_FALSE(dir()->InitialSyncEndedForType(&trans, PREFERENCES));
 
   // Mark as complete and verify.
   dir()->MarkInitialSyncEndedForType(&trans, PREFERENCES);
   EXPECT_TRUE(dir()->InitialSyncEndedForType(&trans, PREFERENCES));
 }
 
 }  // namespace syncable
 
 }  // namespace syncer