Convert //base to use std::unique_ptr

base/containers/mru_cache_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/containers/mru_cache.h"
+
 #include <stddef.h>
 
-#include "base/containers/mru_cache.h"
-#include "base/memory/scoped_ptr.h"
+#include <memory>

[Nico, 2016/04/04 17:14:55]

(nit: in a previous file that included ptr_util, you didn't include <memory>; i
figured the reasoning there was that ptr_util must include <memory>. anyhoo,
fine as-is, but the cl isn't self-consistent on this as far as i can tell)

[dcheng, 2016/04/04 17:43:38]

The automated rules are this:
- scoped_ptr.h, if present, gets rewritten to <memory>
- if the file references WrapUnique, the header ptr_util.h is inserted.
- if something outside //base failed to compile, that means they forgot to IWYU
for scoped_ptr.h and so they get an #include for scoped_ptr.h.

I didn't attempt to get fancier than that. AFAIK, there are no formal rules
around when a translation unit can assume an included header exposes another
header as a public dep (e.g. ptr_util.h exposing <memory>). I could try to make
it self-consistent, but given the current lack of any automated enforcement,
it's just going to quickly revert to the status quo. So I don't think it's worth
the additional work it'd entail.

+
+#include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 int cached_item_live_count = 0;
 
 struct CachedItem {
   CachedItem() : value(0) {
     cached_item_live_count++;
   }
@@ skipping 162 matching lines @@
   // Make it so only the most important element is there.
   cache.ShrinkToSize(1);
 
   Cache::iterator iter = cache.begin();
   EXPECT_EQ(kItem3Key, iter->first);
   EXPECT_EQ(item5.value, iter->second.value);
 }
 
 // Make sure that the owning version release its pointers properly.
 TEST(MRUCacheTest, Owning) {
-  using Cache = base::MRUCache<int, scoped_ptr<CachedItem>>;
+  using Cache = base::MRUCache<int, std::unique_ptr<CachedItem>>;
   Cache cache(Cache::NO_AUTO_EVICT);
 
   int initial_count = cached_item_live_count;
 
   // First insert and item and then overwrite it.
   static const int kItem1Key = 1;
-  cache.Put(kItem1Key, make_scoped_ptr(new CachedItem(20)));
-  cache.Put(kItem1Key, make_scoped_ptr(new CachedItem(22)));
+  cache.Put(kItem1Key, WrapUnique(new CachedItem(20)));
+  cache.Put(kItem1Key, WrapUnique(new CachedItem(22)));
 
   // There should still be one item, and one extra live item.
   Cache::iterator iter = cache.Get(kItem1Key);
   EXPECT_EQ(1U, cache.size());
   EXPECT_TRUE(iter != cache.end());
   EXPECT_EQ(initial_count + 1, cached_item_live_count);
 
   // Now remove it.
   cache.Erase(cache.begin());
   EXPECT_EQ(initial_count, cached_item_live_count);
 
   // Now try another cache that goes out of scope to make sure its pointers
   // go away.
   {
     Cache cache2(Cache::NO_AUTO_EVICT);
-    cache2.Put(1, make_scoped_ptr(new CachedItem(20)));
-    cache2.Put(2, make_scoped_ptr(new CachedItem(20)));
+    cache2.Put(1, WrapUnique(new CachedItem(20)));
+    cache2.Put(2, WrapUnique(new CachedItem(20)));
   }
 
   // There should be no objects leaked.
   EXPECT_EQ(initial_count, cached_item_live_count);
 
   // Check that Clear() also frees things correctly.
   {
     Cache cache2(Cache::NO_AUTO_EVICT);
-    cache2.Put(1, make_scoped_ptr(new CachedItem(20)));
-    cache2.Put(2, make_scoped_ptr(new CachedItem(20)));
+    cache2.Put(1, WrapUnique(new CachedItem(20)));
+    cache2.Put(2, WrapUnique(new CachedItem(20)));
     EXPECT_EQ(initial_count + 2, cached_item_live_count);
     cache2.Clear();
     EXPECT_EQ(initial_count, cached_item_live_count);
   }
 }
 
 TEST(MRUCacheTest, AutoEvict) {
-  using Cache = base::MRUCache<int, scoped_ptr<CachedItem>>;
+  using Cache = base::MRUCache<int, std::unique_ptr<CachedItem>>;
   static const Cache::size_type kMaxSize = 3;
 
   int initial_count = cached_item_live_count;
 
   {
     Cache cache(kMaxSize);
 
     static const int kItem1Key = 1, kItem2Key = 2, kItem3Key = 3, kItem4Key = 4;
-    cache.Put(kItem1Key, make_scoped_ptr(new CachedItem(20)));
-    cache.Put(kItem2Key, make_scoped_ptr(new CachedItem(21)));
-    cache.Put(kItem3Key, make_scoped_ptr(new CachedItem(22)));
-    cache.Put(kItem4Key, make_scoped_ptr(new CachedItem(23)));
+    cache.Put(kItem1Key, WrapUnique(new CachedItem(20)));
+    cache.Put(kItem2Key, WrapUnique(new CachedItem(21)));
+    cache.Put(kItem3Key, WrapUnique(new CachedItem(22)));
+    cache.Put(kItem4Key, WrapUnique(new CachedItem(23)));
 
     // The cache should only have kMaxSize items in it even though we inserted
     // more.
     EXPECT_EQ(kMaxSize, cache.size());
   }
 
   // There should be no objects leaked.
   EXPECT_EQ(initial_count, cached_item_live_count);
 }
 
@@ skipping 111 matching lines @@
     ASSERT_TRUE(iter != cache2.end());
     EXPECT_EQ(kItem2Key, iter->first);
     EXPECT_EQ(item2.value, iter->second.value);
 
     ++iter;
     ASSERT_TRUE(iter != cache2.end());
     EXPECT_EQ(kItem1Key, iter->first);
     EXPECT_EQ(item1.value, iter->second.value);
   }
 }