Convert //sync from scoped_ptr to std::unique_ptr

sync/syncable/directory_backing_store_unittest.cc

 // Copyright 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 "sync/syncable/directory_backing_store.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/test/scoped_error_ignorer.h"
 #include "sql/test/test_helpers.h"
@@ skipping 13 matching lines @@
 namespace syncer {
 namespace syncable {
 namespace {
 
 // A handler that simply sets |catastrophic_error_handler_was_called| to true.
 void CatastrophicErrorHandler(bool* catastrophic_error_handler_was_called) {
   *catastrophic_error_handler_was_called = true;
 }
 
 // Create a dirty EntryKernel with an ID derived from |id| + |id_suffix|.
-scoped_ptr<EntryKernel> CreateEntry(int id, const std::string &id_suffix) {
-  scoped_ptr<EntryKernel> entry(new EntryKernel());
+std::unique_ptr<EntryKernel> CreateEntry(int id, const std::string& id_suffix) {
+  std::unique_ptr<EntryKernel> entry(new EntryKernel());
   std::string id_string = base::Int64ToString(id) + id_suffix;
   entry->put(ID, Id::CreateFromClientString(id_string));
   entry->put(META_HANDLE, id);
   entry->mark_dirty(NULL);
   return entry;
 }
 
 }  // namespace
 
 SYNC_EXPORT extern const int32_t kCurrentPageSizeKB;
@@ skipping 42 matching lines @@
   void SetUpVersion84Database(sql::Connection* connection);
   void SetUpVersion85Database(sql::Connection* connection);
   void SetUpVersion86Database(sql::Connection* connection);
   void SetUpVersion87Database(sql::Connection* connection);
   void SetUpVersion88Database(sql::Connection* connection);
   void SetUpVersion89Database(sql::Connection* connection);
   void SetUpVersion90Database(sql::Connection* connection);
 
   void SetUpCurrentDatabaseAndCheckVersion(sql::Connection* connection) {
     SetUpVersion90Database(connection);  // Prepopulates data.
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), connection));
     ASSERT_EQ(kCurrentDBVersion, dbs->GetVersion());
 
     ASSERT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
 
  private:
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_dir_;
@@ skipping 2882 matching lines @@
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
 
   SetUpVersion67Database(&connection);
 
   // Columns existing before version 67.
   ASSERT_TRUE(connection.DoesColumnExist("metas", "name"));
   ASSERT_TRUE(connection.DoesColumnExist("metas", "unsanitized_name"));
   ASSERT_TRUE(connection.DoesColumnExist("metas", "server_name"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
 
   ASSERT_FALSE(dbs->needs_column_refresh());
   ASSERT_TRUE(dbs->MigrateVersion67To68());
   ASSERT_EQ(68, dbs->GetVersion());
   ASSERT_TRUE(dbs->needs_column_refresh());
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion68To69) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion68Database(&connection);
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
 
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion68To69());
     ASSERT_EQ(69, dbs->GetVersion());
     ASSERT_TRUE(dbs->needs_column_refresh());
   }
 
   ASSERT_TRUE(connection.DoesColumnExist("metas", "specifics"));
   ASSERT_TRUE(connection.DoesColumnExist("metas", "server_specifics"));
@@ skipping 20 matching lines @@
 TEST_F(DirectoryBackingStoreTest, MigrateVersion69To70) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion69Database(&connection);
 
   ASSERT_TRUE(connection.DoesColumnExist("metas", "singleton_tag"));
   ASSERT_FALSE(connection.DoesColumnExist("metas", "unique_server_tag"));
   ASSERT_FALSE(connection.DoesColumnExist("metas", "unique_client_tag"));
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
 
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion69To70());
     ASSERT_EQ(70, dbs->GetVersion());
     ASSERT_TRUE(dbs->needs_column_refresh());
   }
 
   EXPECT_TRUE(connection.DoesColumnExist("metas", "unique_server_tag"));
   EXPECT_TRUE(connection.DoesColumnExist("metas", "unique_client_tag"));
   sql::Statement s(connection.GetUniqueStatement("SELECT id"
       " FROM metas WHERE unique_server_tag = 'google_chrome'"));
   ASSERT_TRUE(s.Step());
   EXPECT_EQ("s_ID_7", s.ColumnString(0));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion70To71) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion70Database(&connection);
 
   ASSERT_TRUE(connection.DoesColumnExist("share_info", "last_sync_timestamp"));
   ASSERT_TRUE(connection.DoesColumnExist("share_info", "initial_sync_ended"));
   ASSERT_FALSE(connection.DoesTableExist("models"));
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
 
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion70To71());
     ASSERT_EQ(71, dbs->GetVersion());
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
 
   ASSERT_FALSE(connection.DoesColumnExist("share_info", "last_sync_timestamp"));
   ASSERT_FALSE(connection.DoesColumnExist("share_info", "initial_sync_ended"));
@@ skipping 15 matching lines @@
 
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion71To72) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion71Database(&connection);
 
   ASSERT_TRUE(connection.DoesTableExist("extended_attributes"));
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
 
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion71To72());
     ASSERT_EQ(72, dbs->GetVersion());
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
 
   ASSERT_FALSE(connection.DoesTableExist("extended_attributes"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion72To73) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion72Database(&connection);
 
   ASSERT_FALSE(connection.DoesColumnExist("share_info", "notification_state"));
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
 
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion72To73());
     ASSERT_EQ(73, dbs->GetVersion());
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
 
   ASSERT_TRUE(connection.DoesColumnExist("share_info", "notification_state"));
 }
@@ skipping 12 matching lines @@
       connection.DoesColumnExist("share_info", "autofill_migration_time"));
   ASSERT_FALSE(
       connection.DoesColumnExist("share_info",
           "autofill_entries_added_during_migration"));
 
   ASSERT_FALSE(
       connection.DoesColumnExist("share_info",
           "autofill_profiles_added_during_migration"));
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
 
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion73To74());
     ASSERT_EQ(74, dbs->GetVersion());
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
 
   ASSERT_TRUE(
       connection.DoesColumnExist("share_info", "autofill_migration_state"));
@@ skipping 13 matching lines @@
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion74To75) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion74Database(&connection);
 
   ASSERT_FALSE(connection.DoesColumnExist("models", "progress_marker"));
   ASSERT_TRUE(connection.DoesColumnExist("models", "last_download_timestamp"));
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
 
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion74To75());
     ASSERT_EQ(75, dbs->GetVersion());
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
 
   ASSERT_TRUE(connection.DoesColumnExist("models", "progress_marker"));
   ASSERT_FALSE(connection.DoesColumnExist("models", "last_download_timestamp"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion75To76) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion75Database(&connection);
 
   ASSERT_TRUE(
       connection.DoesColumnExist("share_info", "autofill_migration_state"));
   ASSERT_TRUE(connection.DoesColumnExist("share_info",
       "bookmarks_added_during_autofill_migration"));
   ASSERT_TRUE(
       connection.DoesColumnExist("share_info", "autofill_migration_time"));
   ASSERT_TRUE(connection.DoesColumnExist("share_info",
       "autofill_entries_added_during_migration"));
   ASSERT_TRUE(connection.DoesColumnExist("share_info",
       "autofill_profiles_added_during_migration"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh());
   ASSERT_TRUE(dbs->MigrateVersion75To76());
   ASSERT_EQ(76, dbs->GetVersion());
   ASSERT_TRUE(dbs->needs_column_refresh());
   // Cannot actual refresh columns due to version 76 not containing all
   // necessary columns.
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion76To77) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion76Database(&connection);
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh());
 
   EXPECT_EQ(GetExpectedLegacyMetaProtoTimes(INCLUDE_DELETED_ITEMS),
             GetMetaProtoTimes(&connection));
   // Since the proto times are expected to be in a legacy format, they may not
   // be compatible with ProtoTimeToTime, so we don't call ExpectTimes().
 
   ASSERT_TRUE(dbs->MigrateVersion76To77());
   ASSERT_EQ(77, dbs->GetVersion());
 
   EXPECT_EQ(GetExpectedMetaProtoTimes(INCLUDE_DELETED_ITEMS),
             GetMetaProtoTimes(&connection));
   // Cannot actually load entries due to version 77 not having all required
   // columns.
   ASSERT_FALSE(dbs->needs_column_refresh());
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion77To78) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion77Database(&connection);
 
   ASSERT_FALSE(connection.DoesColumnExist("metas", "BASE_SERVER_SPECIFICS"));
 
   {
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_TRUE(dbs->MigrateVersion77To78());
     ASSERT_EQ(78, dbs->GetVersion());
 
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
 
   ASSERT_TRUE(connection.DoesColumnExist("metas", "base_server_specifics"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion78To79) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion78Database(&connection);
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh());
   ASSERT_TRUE(dbs->MigrateVersion78To79());
   ASSERT_EQ(79, dbs->GetVersion());
   ASSERT_FALSE(dbs->needs_column_refresh());
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion79To80) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion79Database(&connection);
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh());
   ASSERT_TRUE(dbs->MigrateVersion79To80());
   ASSERT_EQ(80, dbs->GetVersion());
   ASSERT_FALSE(dbs->needs_column_refresh());
 
   // Ensure the bag_of_chips has been set.
   Directory::MetahandlesMap handles_map;
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
@@ skipping 13 matching lines @@
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion80Database(&connection);
 
   sql::Statement s(connection.GetUniqueStatement(
       "SELECT metahandle, server_position_in_parent "
       "FROM metas WHERE unique_server_tag = 'google_chrome'"));
   ASSERT_TRUE(s.Step());
   ASSERT_EQ(sql::COLUMN_TYPE_INTEGER, s.ColumnType(1));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion80To81());
   ASSERT_EQ(81, dbs->GetVersion());
 
   // Test that ordinal values are preserved correctly.
   sql::Statement new_s(connection.GetUniqueStatement(
       "SELECT metahandle, server_ordinal_in_parent "
       "FROM metas WHERE unique_server_tag = 'google_chrome'"));
   ASSERT_TRUE(new_s.Step());
   ASSERT_EQ(sql::COLUMN_TYPE_BLOB, new_s.ColumnType(1));
 
   std::string expected_ordinal = Int64ToNodeOrdinal(1048576).ToInternalValue();
   std::string actual_ordinal;
   new_s.ColumnBlobAsString(1, &actual_ordinal);
   ASSERT_EQ(expected_ordinal, actual_ordinal);
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion81To82) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion81Database(&connection);
   ASSERT_FALSE(connection.DoesColumnExist("models", "transaction_version"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh());
   ASSERT_TRUE(dbs->MigrateVersion81To82());
   ASSERT_EQ(82, dbs->GetVersion());
   ASSERT_FALSE(dbs->needs_column_refresh());
 
   ASSERT_TRUE(connection.DoesColumnExist("models", "transaction_version"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion82To83) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion82Database(&connection);
   ASSERT_FALSE(connection.DoesColumnExist("metas", "transaction_version"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion82To83());
   ASSERT_EQ(83, dbs->GetVersion());
 
   ASSERT_TRUE(connection.DoesColumnExist("metas", "transaction_version"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion83To84) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion83Database(&connection);
   ASSERT_FALSE(connection.DoesTableExist("deleted_metas"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion83To84());
   ASSERT_EQ(84, dbs->GetVersion());
 
   ASSERT_TRUE(connection.DoesTableExist("deleted_metas"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion84To85) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion84Database(&connection);
   ASSERT_TRUE(connection.DoesColumnExist("models", "initial_sync_ended"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion84To85());
   ASSERT_EQ(85, dbs->GetVersion());
   ASSERT_FALSE(connection.DoesColumnExist("models", "initial_sync_ended"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion85To86) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion85Database(&connection);
   EXPECT_TRUE(connection.DoesColumnExist("metas", "next_id"));
   EXPECT_TRUE(connection.DoesColumnExist("metas", "prev_id"));
   EXPECT_TRUE(connection.DoesColumnExist("metas", "server_ordinal_in_parent"));
   EXPECT_FALSE(connection.DoesColumnExist("metas", "unique_position"));
   EXPECT_FALSE(connection.DoesColumnExist("metas", "server_unique_position"));
   EXPECT_FALSE(connection.DoesColumnExist("metas", "unique_bookmark_tag"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion85To86());
   EXPECT_EQ(86, dbs->GetVersion());
   EXPECT_TRUE(connection.DoesColumnExist("metas", "unique_position"));
   EXPECT_TRUE(connection.DoesColumnExist("metas", "server_unique_position"));
   EXPECT_TRUE(connection.DoesColumnExist("metas", "unique_bookmark_tag"));
   ASSERT_TRUE(dbs->needs_column_refresh());
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion86To87) {
   sql::Connection connection;
   EXPECT_TRUE(connection.OpenInMemory());
   SetUpVersion86Database(&connection);
   EXPECT_FALSE(connection.DoesColumnExist("metas", "attachment_metadata"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   EXPECT_TRUE(dbs->MigrateVersion86To87());
   EXPECT_EQ(87, dbs->GetVersion());
   EXPECT_TRUE(connection.DoesColumnExist("metas", "attachment_metadata"));
   EXPECT_TRUE(dbs->needs_column_refresh());
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion87To88) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion87Database(&connection);
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion87To88());
   ASSERT_EQ(88, dbs->GetVersion());
   ASSERT_TRUE(connection.DoesColumnExist("models", "context"));
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion88To89) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion88Database(&connection);
   ASSERT_FALSE(
       connection.DoesColumnExist("metas", "server_attachment_metadata"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion88To89());
   ASSERT_EQ(89, dbs->GetVersion());
   EXPECT_TRUE(
       connection.DoesColumnExist("metas", "server_attachment_metadata"));
   EXPECT_TRUE(dbs->needs_column_refresh());
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion89To90) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion89Database(&connection);
   ASSERT_TRUE(connection.DoesColumnExist("share_info", "db_create_version"));
   ASSERT_TRUE(connection.DoesColumnExist("share_info", "db_create_time"));
   ASSERT_TRUE(connection.DoesColumnExist("share_info", "next_id"));
   ASSERT_TRUE(connection.DoesColumnExist("share_info", "notification_state"));
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_TRUE(dbs->MigrateVersion89To90());
   ASSERT_EQ(90, dbs->GetVersion());
   EXPECT_TRUE(dbs->needs_column_refresh());
 
   ASSERT_TRUE(dbs->RefreshColumns());
   EXPECT_FALSE(dbs->needs_column_refresh());
 
   ASSERT_FALSE(connection.DoesColumnExist("share_info", "db_create_version"));
   ASSERT_FALSE(connection.DoesColumnExist("share_info", "db_create_time"));
@@ skipping 17 matching lines @@
 //        > .dump
 //   5. Replace the timestamp columns with META_PROTO_TIMES(x) (or
 //      LEGACY_META_PROTO_TIMES(x) if before Version 77). Use this dump to write
 //      a SetupVersionYDatabase method.
 TEST_F(DirectoryBackingStoreTest, MigrateToLatestAndDump) {
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     SetUpVersion89Database(&connection);  // Update this.
 
-    scoped_ptr<TestDirectoryBackingStore> dbs(
+    std::unique_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
     ASSERT_TRUE(dbs->MigrateVersion89To90());  // Update this.
     ASSERT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
     EXPECT_EQ(90, dbs->GetVersion());  // Update this.
     ASSERT_FALSE(dbs->needs_column_refresh());
   }
   // Set breakpoint here.
 }
 
 TEST_F(DirectoryBackingStoreTest, DetectInvalidPosition) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion86Database(&connection);
 
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_EQ(86, dbs->GetVersion());
 
   // Insert row with bad position.
   sql::Statement s(connection.GetUniqueStatement(
       "INSERT INTO metas "
       "( id, metahandle, is_dir, ctime, mtime,"
       "  unique_position, server_unique_position) "
       "VALUES('c-invalid', 9999, 1, 0, 0, 'BAD_POS', 'BAD_POS')"));
   ASSERT_TRUE(s.Run());
@@ skipping 97 matching lines @@
   }
   connection.Close();
 
   syncable::Directory::KernelLoadInfo dir_info;
   Directory::MetahandlesMap handles_map;
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
   STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   {
-    scoped_ptr<OnDiskDirectoryBackingStore> dbs(
+    std::unique_ptr<OnDiskDirectoryBackingStore> dbs(
         new OnDiskDirectoryBackingStore(GetUsername(), GetDatabasePath()));
     ASSERT_EQ(OPENED, dbs->Load(&handles_map, &delete_journals,
                                 &metahandles_to_purge, &dir_info));
     if (!metahandles_to_purge.empty())
       dbs->DeleteEntries(DirectoryBackingStore::METAS_TABLE,
                          metahandles_to_purge);
     ASSERT_FALSE(dbs->needs_column_refresh());
     ASSERT_EQ(kCurrentDBVersion, dbs->GetVersion());
     int pageSize = 0;
     ASSERT_TRUE(dbs->GetDatabasePageSize(&pageSize));
@@ skipping 329 matching lines @@
 }  // namespace
 
 // This is a whitebox test intended to exercise the code path where the on-disk
 // directory load code decides to delete the current directory and start fresh.
 //
 // This is considered "minor" corruption because the database recreation is
 // expected to succeed.  The alternative, where recreation does not succeed (ie.
 // due to read-only file system), is not tested here.
 TEST_F(DirectoryBackingStoreTest, MinorCorruption) {
   {
-    scoped_ptr<OnDiskDirectoryBackingStore> dbs(
+    std::unique_ptr<OnDiskDirectoryBackingStore> dbs(
         new OnDiskDirectoryBackingStore(GetUsername(), GetDatabasePath()));
     EXPECT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
   }
 
   // Corrupt the root node.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(connection.Execute(
             "UPDATE metas SET parent_id='bogus' WHERE id = 'r';"));
   }
 
   {
-    scoped_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
+    std::unique_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
         new OnDiskDirectoryBackingStoreForTest(GetUsername(),
                                                GetDatabasePath()));
 
     EXPECT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
     EXPECT_TRUE(dbs->DidFailFirstOpenAttempt());
   }
 }
 
 TEST_F(DirectoryBackingStoreTest, MinorCorruptionAndUpgrade) {
   {
-    scoped_ptr<OnDiskDirectoryBackingStore> dbs(
+    std::unique_ptr<OnDiskDirectoryBackingStore> dbs(
         new OnDiskDirectoryBackingStore(GetUsername(), GetDatabasePath()));
     EXPECT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
   }
 
   // Make the node look outdated with an invalid version.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(connection.Execute("UPDATE share_version SET data = 0;"));
     ASSERT_TRUE(connection.Execute("PRAGMA page_size=4096;"));
     ASSERT_TRUE(connection.Execute("VACUUM;"));
   }
 
   {
-    scoped_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
+    std::unique_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
         new OnDiskDirectoryBackingStoreForTest(GetUsername(),
                                                GetDatabasePath()));
     dbs->SetCatastrophicErrorHandler(base::Bind(&base::DoNothing));
 
     EXPECT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
     EXPECT_TRUE(dbs->DidFailFirstOpenAttempt());
 
     int page_size = 0;
     ASSERT_TRUE(dbs->GetDatabasePageSize(&page_size));
     EXPECT_EQ(kCurrentPageSizeKB, page_size);
   }
 }
 
 TEST_F(DirectoryBackingStoreTest, DeleteEntries) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
 
   SetUpCurrentDatabaseAndCheckVersion(&connection);
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   Directory::MetahandlesMap handles_map;
   JournalIndex  delete_journals;
   MetahandleSet metahandles_to_purge;
   Directory::KernelLoadInfo kernel_load_info;
   STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
             &kernel_load_info);
   size_t initial_size = handles_map.size();
@@ skipping 40 matching lines @@
   // In theory this test can fail, but it won't before the universe
   // dies of heat death.
   EXPECT_NE(guid1, guid2);
 }
 
 TEST_F(DirectoryBackingStoreTest, IncreaseDatabasePageSizeFrom4KTo32K) {
   sql::Connection connection;
   ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
   SetUpCurrentDatabaseAndCheckVersion(&connection);
-  scoped_ptr<TestDirectoryBackingStore> dbs(
+  std::unique_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   Directory::MetahandlesMap handles_map;
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
   Directory::KernelLoadInfo kernel_load_info;
   STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   DirOpenResult open_result = dbs->Load(
       &handles_map, &delete_journals, &metahandles_to_purge, &kernel_load_info);
   EXPECT_EQ(open_result, OPENED);
 
   // Set up database's page size to 4096
   EXPECT_TRUE(dbs->db_->Execute("PRAGMA page_size=4096;"));
   EXPECT_TRUE(dbs->Vacuum());
 
   // Check if update is successful.
   int pageSize = 0;
   EXPECT_TRUE(dbs->GetDatabasePageSize(&pageSize));
   EXPECT_NE(kCurrentPageSizeKB, pageSize);
   EXPECT_TRUE(dbs->UpdatePageSizeIfNecessary());
   pageSize = 0;
   EXPECT_TRUE(dbs->GetDatabasePageSize(&pageSize));
   EXPECT_EQ(kCurrentPageSizeKB, pageSize);
 }
 
 // See that a catastrophic error handler remains set across instances of the
 // underlying sql:Connection.
 TEST_F(DirectoryBackingStoreTest, CatastrophicErrorHandler_KeptAcrossReset) {
-  scoped_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
+  std::unique_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
       new OnDiskDirectoryBackingStoreForTest(GetUsername(), GetDatabasePath()));
   // See that by default there is no catastrophic error handler.
   ASSERT_FALSE(dbs->db_->has_error_callback());
   // Set one and see that it was set.
   dbs->SetCatastrophicErrorHandler(
       base::Bind(&CatastrophicErrorHandler, nullptr));
   ASSERT_TRUE(dbs->db_->has_error_callback());
   // Recreate the Connection and see that the handler remains set.
   dbs->ResetAndCreateConnection();
   ASSERT_TRUE(dbs->db_->has_error_callback());
 }
 
 // Verify that database corruption encountered during Load will trigger the
 // catastrohpic error handler.
 TEST_F(DirectoryBackingStoreTest,
        CatastrophicErrorHandler_InvocationDuringLoad) {
   bool was_called = false;
   const base::Closure handler =
       base::Bind(&CatastrophicErrorHandler, &was_called);
   {
-    scoped_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
+    std::unique_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
         new OnDiskDirectoryBackingStoreForTest(GetUsername(),
                                                GetDatabasePath()));
     dbs->SetCatastrophicErrorHandler(handler);
     ASSERT_TRUE(dbs->db_->has_error_callback());
     // Load the DB, and save one entry.
     ASSERT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
     ASSERT_FALSE(dbs->DidFailFirstOpenAttempt());
     Directory::SaveChangesSnapshot snapshot;
     snapshot.dirty_metas.insert(CreateEntry(2, "").release());
     ASSERT_TRUE(dbs->SaveChanges(snapshot));
   }
 
   base::RunLoop().RunUntilIdle();
   // No catastrophic errors have happened. See that it hasn't be called yet.
   ASSERT_FALSE(was_called);
 
   // Corrupt the DB. Some forms of corruption (like this one) will be detected
   // upon loading the Sync DB.
   ASSERT_TRUE(sql::test::CorruptSizeInHeader(GetDatabasePath()));
 
   {
-    scoped_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
+    std::unique_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
         new OnDiskDirectoryBackingStoreForTest(GetUsername(),
                                                GetDatabasePath()));
     dbs->SetCatastrophicErrorHandler(handler);
     ASSERT_TRUE(dbs->db_->has_error_callback());
     {
       // The corruption will be detected when we attempt to load the data. Use a
       // ScopedErrorIgnorer to ensure we don't crash in debug builds.
       sql::ScopedErrorIgnorer error_ignorer;
       error_ignorer.IgnoreError(SQLITE_CORRUPT);
       ASSERT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
@@ skipping 11 matching lines @@
 }
 
 // Verify that database corruption encountered during SaveChanges will trigger
 // the catastrohpic error handler.
 TEST_F(DirectoryBackingStoreTest,
        CatastrophicErrorHandler_InvocationDuringSaveChanges) {
   bool was_called = false;
   const base::Closure handler =
       base::Bind(&CatastrophicErrorHandler, &was_called);
   // Create a DB with many entries.
-  scoped_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
+  std::unique_ptr<OnDiskDirectoryBackingStoreForTest> dbs(
       new OnDiskDirectoryBackingStoreForTest(GetUsername(), GetDatabasePath()));
   dbs->SetCatastrophicErrorHandler(handler);
   ASSERT_TRUE(dbs->db_->has_error_callback());
   ASSERT_TRUE(LoadAndIgnoreReturnedData(dbs.get()));
   ASSERT_FALSE(dbs->DidFailFirstOpenAttempt());
   Directory::SaveChangesSnapshot snapshot;
   const std::string suffix(400, 'o');
   for (int i = 0; i < corruption_testing::kNumEntriesRequiredForCorruption;
        ++i) {
-    scoped_ptr<EntryKernel> large_entry = CreateEntry(i, suffix);
+    std::unique_ptr<EntryKernel> large_entry = CreateEntry(i, suffix);
     snapshot.dirty_metas.insert(large_entry.release());
   }
   ASSERT_TRUE(dbs->SaveChanges(snapshot));
   // Corrupt it.
   ASSERT_TRUE(corruption_testing::CorruptDatabase(GetDatabasePath()));
   // Attempt to save all those entries again. See that it fails (because of the
   // corruption).
   //
   // If this test fails because SaveChanges returned true, it may mean you need
   // to increase the number of entries written to the DB. See also
   // |kNumEntriesRequiredForCorruption|.
   ASSERT_FALSE(dbs->SaveChanges(snapshot));
   // At this point the handler has been posted but not executed.
   ASSERT_FALSE(was_called);
   // Pump the message loop and see that it is executed.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
 }
 
 }  // namespace syncable
 }  // namespace syncer