Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

base/id_map_unittest.cc

 // Copyright (c) 2011 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 "base/id_map.h"
 
 #include <stdint.h>
 
+#include <memory>
+
+#include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestObject {
 };
 
 class DestructorCounter {
  public:
   explicit DestructorCounter(int* counter) : counter_(counter) {}
@@ skipping 232 matching lines @@
 }
 
 TEST(IDMapTest, OwningPointersDeletesThemOnRemove) {
   const int kCount = 3;
 
   int external_del_count = 0;
   DestructorCounter* external_obj[kCount];
   int map_external_ids[kCount];
 
   int owned_del_count = 0;
-  DestructorCounter* owned_obj[kCount];
   int map_owned_ids[kCount];
 
   IDMap<DestructorCounter> map_external;
   IDMap<DestructorCounter, IDMapOwnPointer> map_owned;
 
   for (int i = 0; i < kCount; ++i) {
     external_obj[i] = new DestructorCounter(&external_del_count);
     map_external_ids[i] = map_external.Add(external_obj[i]);
 
-    owned_obj[i] = new DestructorCounter(&owned_del_count);
-    map_owned_ids[i] = map_owned.Add(owned_obj[i]);
+    map_owned_ids[i] =
+        map_owned.Add(base::MakeUnique<DestructorCounter>(&owned_del_count));
   }
 
   for (int i = 0; i < kCount; ++i) {
     EXPECT_EQ(external_del_count, 0);
     EXPECT_EQ(owned_del_count, i);
 
     map_external.Remove(map_external_ids[i]);
     map_owned.Remove(map_owned_ids[i]);
   }
 
   for (int i = 0; i < kCount; ++i) {
     delete external_obj[i];
   }
 
   EXPECT_EQ(external_del_count, kCount);
   EXPECT_EQ(owned_del_count, kCount);
 }
 
 TEST(IDMapTest, OwningPointersDeletesThemOnClear) {
   const int kCount = 3;
 
   int external_del_count = 0;
   DestructorCounter* external_obj[kCount];
 
   int owned_del_count = 0;
-  DestructorCounter* owned_obj[kCount];
 
   IDMap<DestructorCounter> map_external;
   IDMap<DestructorCounter, IDMapOwnPointer> map_owned;
 
   for (int i = 0; i < kCount; ++i) {
     external_obj[i] = new DestructorCounter(&external_del_count);
     map_external.Add(external_obj[i]);
 
-    owned_obj[i] = new DestructorCounter(&owned_del_count);
-    map_owned.Add(owned_obj[i]);
+    map_owned.Add(base::MakeUnique<DestructorCounter>(&owned_del_count));
   }
 
   EXPECT_EQ(external_del_count, 0);
   EXPECT_EQ(owned_del_count, 0);
 
   map_external.Clear();
   map_owned.Clear();
 
   EXPECT_EQ(external_del_count, 0);
   EXPECT_EQ(owned_del_count, kCount);
 
   for (int i = 0; i < kCount; ++i) {
     delete external_obj[i];
   }
 
   EXPECT_EQ(external_del_count, kCount);
   EXPECT_EQ(owned_del_count, kCount);
 }
 
 TEST(IDMapTest, OwningPointersDeletesThemOnDestruct) {
   const int kCount = 3;
 
   int external_del_count = 0;
   DestructorCounter* external_obj[kCount];
 
   int owned_del_count = 0;
-  DestructorCounter* owned_obj[kCount];
 
   {
     IDMap<DestructorCounter> map_external;
     IDMap<DestructorCounter, IDMapOwnPointer> map_owned;
 
     for (int i = 0; i < kCount; ++i) {
       external_obj[i] = new DestructorCounter(&external_del_count);
       map_external.Add(external_obj[i]);
 
-      owned_obj[i] = new DestructorCounter(&owned_del_count);
-      map_owned.Add(owned_obj[i]);
+      map_owned.Add(base::MakeUnique<DestructorCounter>(&owned_del_count));
     }
   }
 
   EXPECT_EQ(external_del_count, 0);
 
   for (int i = 0; i < kCount; ++i) {
     delete external_obj[i];
   }
 
   EXPECT_EQ(external_del_count, kCount);
@@ skipping 13 matching lines @@
   EXPECT_EQ(kId1, iter.GetCurrentKey());
   EXPECT_EQ(&obj1, iter.GetCurrentValue());
   iter.Advance();
   ASSERT_TRUE(iter.IsAtEnd());
 
   map.Remove(kId1);
   EXPECT_TRUE(map.IsEmpty());
 }
 
 }  // namespace