Convert //sync from scoped_ptr to std::unique_ptr

sync/engine/directory_commit_contribution_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/engine/directory_commit_contribution.h"
 
 #include <stdint.h>
 
 #include <set>
 #include <string>
@@ skipping 111 matching lines @@
 TEST_F(DirectoryCommitContributionTest, GatherByTypes) {
   int64_t pref1;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> cc(
+  std::unique_ptr<DirectoryCommitContribution> cc(
       DirectoryCommitContribution::Build(dir(), PREFERENCES, 5, &emitter));
   ASSERT_EQ(2U, cc->GetNumEntries());
 
   const std::vector<int64_t>& metahandles = cc->metahandles_;
   EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
               metahandles.end());
   EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
               metahandles.end());
 
   cc->CleanUp();
 }
 
 // Verify that the DirectoryCommitContributionTest builder function
 // truncates if necessary.
 TEST_F(DirectoryCommitContributionTest, GatherAndTruncate) {
   int64_t pref1;
   int64_t pref2;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     pref2 = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> cc(
+  std::unique_ptr<DirectoryCommitContribution> cc(
       DirectoryCommitContribution::Build(dir(), PREFERENCES, 1, &emitter));
   ASSERT_EQ(1U, cc->GetNumEntries());
 
   int64_t only_metahandle = cc->metahandles_[0];
   EXPECT_TRUE(only_metahandle == pref1 || only_metahandle == pref2);
 
   cc->CleanUp();
 }
 
 // Sanity check for building commits from DirectoryCommitContributions.
 // This test makes two CommitContribution objects of different types and uses
 // them to initialize a commit message.  Then it checks that the contents of the
 // commit message match those of the directory they came from.
 TEST_F(DirectoryCommitContributionTest, PrepareCommit) {
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
   DirectoryTypeDebugInfoEmitter emitter1(PREFERENCES, &type_observers_);
   DirectoryTypeDebugInfoEmitter emitter2(EXTENSIONS, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> pref_cc(
+  std::unique_ptr<DirectoryCommitContribution> pref_cc(
       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter1));
-  scoped_ptr<DirectoryCommitContribution> ext_cc(
+  std::unique_ptr<DirectoryCommitContribution> ext_cc(
       DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25, &emitter2));
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
   ext_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
 
   std::set<syncable::Id> ids_for_commit;
   ASSERT_EQ(3, commit_message.entries_size());
@@ skipping 30 matching lines @@
   int64_t pref1;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1 = CreateSyncedItem(&trans, PREFERENCES, "pref1");
     syncable::MutableEntry e1(&trans, syncable::GET_BY_HANDLE, pref1);
     e1.PutIsDel(true);
     e1.PutIsUnsynced(true);
   }
 
   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> pref_cc(
+  std::unique_ptr<DirectoryCommitContribution> pref_cc(
       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter));
   ASSERT_TRUE(pref_cc);
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
   ASSERT_EQ(1, commit_message.entries_size());
   EXPECT_TRUE(
       commit_message.entries(0).specifics().has_preference());
@@ skipping 21 matching lines @@
     sync_pb::MetaInfo* meta_info = bm_specifics->add_meta_info();
     meta_info->set_key("K");
     meta_info->set_value("V");
     e1.PutSpecifics(specifics);
 
     e1.PutIsDel(true);
     e1.PutIsUnsynced(true);
   }
 
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> bm_cc(
+  std::unique_ptr<DirectoryCommitContribution> bm_cc(
       DirectoryCommitContribution::Build(dir(), BOOKMARKS, 25, &emitter));
   ASSERT_TRUE(bm_cc);
 
   sync_pb::ClientToServerMessage message;
   bm_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
   ASSERT_EQ(1, commit_message.entries_size());
 
   const sync_pb::SyncEntity& entity = commit_message.entries(0);
@@ skipping 21 matching lines @@
     bm_specifics->set_title("Chrome");
     e.PutSpecifics(specifics);
 
     e.PutIsDel(false);
     e.PutIsUnsynced(true);
 
     EXPECT_TRUE(e.ShouldMaintainHierarchy());
   }
 
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> bm_cc(
+  std::unique_ptr<DirectoryCommitContribution> bm_cc(
       DirectoryCommitContribution::Build(dir(), BOOKMARKS, 25, &emitter));
 
   sync_pb::ClientToServerMessage message;
   bm_cc->AddToCommitMessage(&message);
   const sync_pb::CommitMessage& commit_message = message.commit();
   bm_cc->CleanUp();
 
   ASSERT_EQ(1, commit_message.entries_size());
   EXPECT_TRUE(commit_message.entries(0).has_parent_id_string());
   EXPECT_FALSE(commit_message.entries(0).parent_id_string().empty());
 }
 
 // Test that preferences do not support hierarchy.
 TEST_F(DirectoryCommitContributionTest, HierarchySupport_Preferences) {
   // Create a normal-looking prefs item.
   int64_t pref1;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     syncable::MutableEntry e(&trans, syncable::GET_BY_HANDLE, pref1);
 
     EXPECT_FALSE(e.ShouldMaintainHierarchy());
   }
 
   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> pref_cc(
+  std::unique_ptr<DirectoryCommitContribution> pref_cc(
       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter));
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
   const sync_pb::CommitMessage& commit_message = message.commit();
   pref_cc->CleanUp();
 
   ASSERT_EQ(1, commit_message.entries_size());
   EXPECT_FALSE(commit_message.entries(0).has_parent_id_string());
   EXPECT_TRUE(commit_message.entries(0).parent_id_string().empty());
@@ skipping 15 matching lines @@
   int64_t ext1_handle;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     pref2_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     ext1_handle = CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
   DirectoryTypeDebugInfoEmitter emitter1(PREFERENCES, &type_observers_);
   DirectoryTypeDebugInfoEmitter emitter2(EXTENSIONS, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> pref_cc(
+  std::unique_ptr<DirectoryCommitContribution> pref_cc(
       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter1));
-  scoped_ptr<DirectoryCommitContribution> ext_cc(
+  std::unique_ptr<DirectoryCommitContribution> ext_cc(
       DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25, &emitter2));
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
   ext_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
   ASSERT_EQ(3, commit_message.entries_size());
 
   sync_pb::ClientToServerResponse response;
@@ skipping 64 matching lines @@
     // art3 has two attachments, neither of which have been uploaded to the
     // server. art2 is not eligible to be committed.
     sync_pb::AttachmentMetadata art3_attachments;
     AddAttachment(&art3_attachments, false /* is_on_server */);
     AddAttachment(&art3_attachments, false /* is_on_server */);
     art3_handle = CreateUnsyncedItemWithAttachments(
         &trans, ARTICLES, "art3", art3_attachments);
   }
 
   DirectoryTypeDebugInfoEmitter emitter(ARTICLES, &type_observers_);
-  scoped_ptr<DirectoryCommitContribution> art_cc(
+  std::unique_ptr<DirectoryCommitContribution> art_cc(
       DirectoryCommitContribution::Build(dir(), ARTICLES, 25, &emitter));
 
   // Only art1 is ready.
   EXPECT_EQ(1U, art_cc->GetNumEntries());
 
   sync_pb::ClientToServerMessage message;
   art_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
   ASSERT_EQ(1, commit_message.entries_size());
@@ skipping 27 matching lines @@
     EXPECT_FALSE(a3.GetId().ServerKnows());
     EXPECT_FALSE(a3.GetSyncing());
     EXPECT_FALSE(a3.GetDirtySync());
     EXPECT_EQ(0, a3.GetServerVersion());
   }
 
   art_cc->CleanUp();
 }
 
 }  // namespace syncer