Remove stl_util from sync.

components/sync/syncable/parent_child_index_unittest.cc

 // Copyright (c) 2013 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 "components/sync/syncable/parent_child_index.h"
 
-#include <list>
 #include <string>
+#include <vector>
 
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/sync/syncable/entry_kernel.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 namespace syncable {
 
 namespace {
 
 static const std::string kCacheGuid = "8HhNIHlEOCGQbIAALr9QEg==";
 
 }  // namespace
 
 class ParentChildIndexTest : public testing::Test {
  public:
-  void TearDown() override {
-    // To make memory management easier, we take ownership of all EntryKernels
-    // returned by our factory methods and delete them here.
-    base::STLDeleteElements(&owned_entry_kernels_);
-  }
+  void TearDown() override {}
 
   // Unfortunately, we can't use the regular Entry factory methods, because the
   // ParentChildIndex deals in EntryKernels.
 
   static syncable::Id GetBookmarkRootId() {
     return syncable::Id::CreateFromServerId("bookmark_folder");
   }
 
   static syncable::Id GetBookmarkId(int n) {
     return syncable::Id::CreateFromServerId("b" + base::IntToString(n));
   }
 
   static syncable::Id GetClientUniqueId(int n) {
     return syncable::Id::CreateFromServerId("c" + base::IntToString(n));
   }
 
   EntryKernel* MakeRoot() {
     // Mimics the root node.
     EntryKernel* root = new EntryKernel();
     root->put(META_HANDLE, 1);
     root->put(BASE_VERSION, -1);
     root->put(SERVER_VERSION, 0);
     root->put(IS_DIR, true);
     root->put(ID, syncable::Id::GetRoot());
     root->put(PARENT_ID, syncable::Id::GetRoot());
 
-    owned_entry_kernels_.push_back(root);
+    owned_entry_kernels_.push_back(base::WrapUnique(root));
     return root;
   }
 
   EntryKernel* MakeTypeRoot(ModelType model_type, const syncable::Id& id) {
     // Mimics a server-created bookmark folder.
     EntryKernel* folder = new EntryKernel;
     folder->put(META_HANDLE, 1);
     folder->put(BASE_VERSION, 9);
     folder->put(SERVER_VERSION, 9);
     folder->put(IS_DIR, true);
     folder->put(ID, id);
     folder->put(PARENT_ID, syncable::Id::GetRoot());
     folder->put(UNIQUE_SERVER_TAG, ModelTypeToRootTag(model_type));
 
     // Ensure that GetModelType() returns a correct value.
     sync_pb::EntitySpecifics specifics;
     AddDefaultFieldValue(model_type, &specifics);
     folder->put(SPECIFICS, specifics);
 
-    owned_entry_kernels_.push_back(folder);
+    owned_entry_kernels_.push_back(base::WrapUnique(folder));
     return folder;
   }
 
   EntryKernel* MakeBookmarkRoot() {
     return MakeTypeRoot(BOOKMARKS, GetBookmarkRootId());
   }
 
   EntryKernel* MakeBookmark(int n, int pos, bool is_dir) {
     // Mimics a regular bookmark or folder.
     EntryKernel* bm = new EntryKernel();
     bm->put(META_HANDLE, n);
     bm->put(BASE_VERSION, 10);
     bm->put(SERVER_VERSION, 10);
     bm->put(IS_DIR, is_dir);
     bm->put(ID, GetBookmarkId(n));
     bm->put(PARENT_ID, GetBookmarkRootId());
 
     bm->put(UNIQUE_BOOKMARK_TAG, syncable::GenerateSyncableBookmarkHash(
                                      kCacheGuid, bm->ref(ID).GetServerId()));
 
     UniquePosition unique_pos =
         UniquePosition::FromInt64(pos, bm->ref(UNIQUE_BOOKMARK_TAG));
     bm->put(UNIQUE_POSITION, unique_pos);
     bm->put(SERVER_UNIQUE_POSITION, unique_pos);
 
-    owned_entry_kernels_.push_back(bm);
+    owned_entry_kernels_.push_back(base::WrapUnique(bm));
     return bm;
   }
 
   EntryKernel* MakeUniqueClientItem(ModelType model_type,
                                     int n,
                                     const syncable::Id& parent_id) {
     EntryKernel* item = new EntryKernel();
     item->put(META_HANDLE, n);
     item->put(BASE_VERSION, 10);
     item->put(SERVER_VERSION, 10);
     item->put(IS_DIR, false);
     item->put(ID, GetClientUniqueId(n));
     item->put(UNIQUE_CLIENT_TAG, base::IntToString(n));
 
     if (!parent_id.IsNull()) {
       item->put(PARENT_ID, parent_id);
     }
 
     if (model_type != UNSPECIFIED) {
       // Ensure that GetModelType() returns a correct value.
       sync_pb::EntitySpecifics specifics;
       AddDefaultFieldValue(model_type, &specifics);
       item->put(SPECIFICS, specifics);
     }
 
-    owned_entry_kernels_.push_back(item);
+    owned_entry_kernels_.push_back(base::WrapUnique(item));
     return item;
   }
 
   EntryKernel* MakeUniqueClientItem(int n, const syncable::Id& parent_id) {
     return MakeUniqueClientItem(UNSPECIFIED, n, parent_id);
   }
 
   EntryKernel* MakeUniqueClientItem(ModelType model_type, int n) {
     return MakeUniqueClientItem(model_type, n, Id());
   }
 
   const syncable::Id& IndexKnownModelTypeRootId(ModelType model_type) const {
     return index_.GetModelTypeRootId(model_type);
   }
 
   ParentChildIndex index_;
 
  private:
-  std::list<EntryKernel*> owned_entry_kernels_;
+  std::vector<std::unique_ptr<EntryKernel>> owned_entry_kernels_;
 };
 
 TEST_F(ParentChildIndexTest, TestRootNode) {
   EntryKernel* root = MakeRoot();
   EXPECT_FALSE(ParentChildIndex::ShouldInclude(root));
 }
 
 TEST_F(ParentChildIndexTest, TestBookmarkRootFolder) {
   EntryKernel* bm_folder = MakeBookmarkRoot();
   EXPECT_TRUE(ParentChildIndex::ShouldInclude(bm_folder));
@@ skipping 355 matching lines @@
   const OrderedChildSet* children = index_.GetChildren(type_root_id);
   ASSERT_TRUE(children);
   EXPECT_EQ(2UL, children->size());
   const OrderedChildSet* children_bad = index_.GetChildren(bad_type_root_id);
   ASSERT_TRUE(children_bad);
   EXPECT_EQ(2UL, children_bad->size());
 }
 
 }  // namespace syncable
 }  // namespace syncer