Convert //chrome from scoped_ptr to std::unique_ptr

chrome/utility/importer/edge_database_reader_unittest_win.cc

 // Copyright 2015 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 "chrome/utility/importer/edge_database_reader_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ skipping 116 matching lines @@
 
 TEST_F(EdgeDatabaseReaderTest, OpenTableDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
 }
 
 TEST_F(EdgeDatabaseReaderTest, InvalidTableDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NotARealTableName");
   EXPECT_EQ(nullptr, table_enum);
 }
 
 TEST_F(EdgeDatabaseReaderTest, NotOpenDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   EdgeDatabaseReader reader;
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_EQ(nullptr, table_enum);
   EXPECT_EQ(JET_errDatabaseNotFound, reader.last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, AlreadyOpenDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   EXPECT_FALSE(reader.OpenDatabase(database_path.value()));
   EXPECT_EQ(JET_errOneDatabasePerSession, reader.last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, OpenTableAndReadDataDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
   int row_count = 0;
   do {
     int32_t int_col_value = 0;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
     EXPECT_EQ(-row_count, int_col_value);
 
     uint32_t uint_col_value = 0;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"UIntCol", &uint_col_value));
@@ skipping 42 matching lines @@
 
 TEST_F(EdgeDatabaseReaderTest, CheckEnumResetDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
   int row_count = 0;
   do {
     row_count++;
   } while (table_enum->Next());
   EXPECT_NE(0, row_count);
   EXPECT_TRUE(table_enum->Reset());
   do {
     row_count--;
   } while (table_enum->Next());
   EXPECT_EQ(0, row_count);
 }
 
 TEST_F(EdgeDatabaseReaderTest, InvalidColumnDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"NotARealNameCol", &int_col_value));
   EXPECT_EQ(JET_errColumnNotFound, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, NoColumnDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NoColsTable");
   EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
   EXPECT_EQ(JET_errColumnNotFound, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, EmptyTableDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"EmptyTable");
   EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
   EXPECT_NE(JET_errColumnNotFound, table_enum->last_error());
   EXPECT_FALSE(table_enum->Reset());
   EXPECT_FALSE(table_enum->Next());
 }
 
 TEST_F(EdgeDatabaseReaderTest, UnicodeStringsDatabaseTest) {
   const char* utf8_strings[] = {
       "\xE3\x81\x93\xE3\x81\xAB\xE3\x81\xA1\xE3\x81\xAF",
       "\xE4\xBD\xA0\xE5\xA5\xBD",
       "\xD0\x97\xD0\xB4\xD1\x80\xD0\xB0\xD0\xB2\xD1\x81\xD1\x82\xD0\xB2\xD1\x83"
       "\xD0\xB9\xD1\x82\xD0\xB5",
       "\x48\x65\x6C\x6C\x6F",
       "\xEC\x95\x88\xEB\x85\x95\xED\x95\x98\xEC\x84\xB8\xEC\x9A\x94",
   };
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"UnicodeTable");
   EXPECT_NE(nullptr, table_enum);
   size_t utf8_strings_count = arraysize(utf8_strings);
   for (size_t row_count = 0; row_count < utf8_strings_count; ++row_count) {
     std::wstring row_string = base::UTF8ToWide(utf8_strings[row_count]);
     base::string16 str_col_value;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
     EXPECT_EQ(row_string, str_col_value);
     if (row_count < utf8_strings_count - 1)
       EXPECT_TRUE(table_enum->Next());
     else
       EXPECT_FALSE(table_enum->Next());
   }
 }
 
 TEST_F(EdgeDatabaseReaderTest, NonUnicodeStringsDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NonUnicodeTable");
   EXPECT_NE(nullptr, table_enum);
   base::string16 str_col_value;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, CheckNullColumnDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NullTable");
   EXPECT_NE(nullptr, table_enum);
 
   // We expect to successfully open a column value but get the default value
   // back.
   int32_t int_col_value = 1;
   EXPECT_TRUE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
   EXPECT_EQ(0, int_col_value);
 
   uint32_t uint_col_value = 1;
@@ skipping 30 matching lines @@
 
 TEST_F(EdgeDatabaseReaderTest, CheckInvalidColumnTypeDatabaseTest) {
   // Only verified to work with ESE library on Windows 7 and above.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
-  scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
+  std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
 
   uint32_t uint_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   // Check unsigned int with a signed int.
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"UIntCol", &int_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"LongLongCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"GuidCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"DateCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"StrCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"BoolCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
 }