Change scoped_ptr to std::unique_ptr in //net.

net/cookies/cookie_monster_perftest.cc

 // Copyright (c) 2012 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 <algorithm>
+#include <memory>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/perf_time_logger.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_monster_store_test.h"
 #include "net/cookies/parsed_cookie.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 const int kNumCookies = 20000;
 const char kCookieLine[] = "A  = \"b=;\\\"\"  ;secure;;;";
 const char kGoogleURL[] = "http://www.google.izzle";
 
 int CountInString(const std::string& str, char c) {
   return std::count(str.begin(), str.end(), c);
 }
 
 class CookieMonsterTest : public testing::Test {
  public:
   CookieMonsterTest() : message_loop_(new base::MessageLoopForIO()) {}
 
  private:
-  scoped_ptr<base::MessageLoop> message_loop_;
+  std::unique_ptr<base::MessageLoop> message_loop_;
 };
 
 class BaseCallback {
  public:
   BaseCallback() : has_run_(false) {}
 
  protected:
   void WaitForCallback() {
     // Note that the performance tests currently all operate on a loaded cookie
     // store (or, more precisely, one that has no backing persistent store).
@@ skipping 65 matching lines @@
   cookie += kCookieLine;
   base::PerfTimeLogger timer("Parsed_cookie_parse_big_cookies");
   for (int i = 0; i < kNumCookies; ++i) {
     ParsedCookie pc(cookie);
     EXPECT_TRUE(pc.IsValid());
   }
   timer.Done();
 }
 
 TEST_F(CookieMonsterTest, TestAddCookiesOnSingleHost) {
-  scoped_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
+  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   std::vector<std::string> cookies;
   for (int i = 0; i < kNumCookies; i++) {
     cookies.push_back(base::StringPrintf("a%03d=b", i));
   }
 
   SetCookieCallback setCookieCallback;
 
   // Add a bunch of cookies on a single host
   base::PerfTimeLogger timer("Cookie_monster_add_single_host");
 
@@ skipping 12 matching lines @@
   }
   timer2.Done();
 
   base::PerfTimeLogger timer3("Cookie_monster_deleteall_single_host");
   cm->DeleteAllAsync(CookieMonster::DeleteCallback());
   base::MessageLoop::current()->RunUntilIdle();
   timer3.Done();
 }
 
 TEST_F(CookieMonsterTest, TestAddCookieOnManyHosts) {
-  scoped_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
+  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   std::string cookie(kCookieLine);
   std::vector<GURL> gurls;  // just wanna have ffffuunnn
   for (int i = 0; i < kNumCookies; ++i) {
     gurls.push_back(GURL(base::StringPrintf("https://a%04d.izzle", i)));
   }
 
   SetCookieCallback setCookieCallback;
 
   // Add a cookie on a bunch of host
   base::PerfTimeLogger timer("Cookie_monster_add_many_hosts");
@@ skipping 12 matching lines @@
   }
   timer2.Done();
 
   base::PerfTimeLogger timer3("Cookie_monster_deleteall_many_hosts");
   cm->DeleteAllAsync(CookieMonster::DeleteCallback());
   base::MessageLoop::current()->RunUntilIdle();
   timer3.Done();
 }
 
 TEST_F(CookieMonsterTest, TestDomainTree) {
-  scoped_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
+  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   GetCookiesCallback getCookiesCallback;
   SetCookieCallback setCookieCallback;
   const char domain_cookie_format_tree[] = "a=b; domain=%s";
   const std::string domain_base("top.com");
 
   std::vector<std::string> domain_list;
 
   // Create a balanced binary tree of domains on which the cookie is set.
   domain_list.push_back(domain_base);
   for (int i1 = 0; i1 < 2; i1++) {
@@ skipping 32 matching lines @@
   EXPECT_EQ(5, CountInString(cookie_line, '='))
       << "Cookie line: " << cookie_line;
   base::PerfTimeLogger timer("Cookie_monster_query_domain_tree");
   for (int i = 0; i < kNumCookies; i++) {
     getCookiesCallback.GetCookies(cm.get(), probe_gurl);
   }
   timer.Done();
 }
 
 TEST_F(CookieMonsterTest, TestDomainLine) {
-  scoped_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
+  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   SetCookieCallback setCookieCallback;
   GetCookiesCallback getCookiesCallback;
   std::vector<std::string> domain_list;
   GURL probe_gurl("https://b.a.b.a.top.com/");
   std::string cookie_line;
 
   // Create a line of 32 domain cookies such that all cookies stored
   // by effective TLD+1 will apply to probe GURL.
   // (TLD + 1 is the level above .com/org/net/etc, e.g. "top.com"
   // or "google.com".  "Effective" is added to include sites like
@@ skipping 40 matching lines @@
       std::string cookie_line(
           base::StringPrintf("Cookie_%d=1; Path=/", cookie_num));
       AddCookieToList(gurl, cookie_line,
                       base::Time::FromInternalValue(time_tick++),
                       &initial_cookies);
     }
   }
 
   store->SetLoadExpectation(true, initial_cookies);
 
-  scoped_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
+  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   // Import will happen on first access.
   GURL gurl("www.google.com");
   CookieOptions options;
   base::PerfTimeLogger timer("Cookie_monster_import_from_store");
   getCookiesCallback.GetCookies(cm.get(), gurl);
   timer.Done();
 
   // Just confirm keys were set as expected.
   EXPECT_EQ("domain_1.com", cm->GetKey("www.Domain_1.com"));
 }
 
 TEST_F(CookieMonsterTest, TestGetKey) {
-  scoped_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
+  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   base::PerfTimeLogger timer("Cookie_monster_get_key");
   for (int i = 0; i < kNumCookies; i++)
     cm->GetKey("www.google.com");
   timer.Done();
 }
 
 // This test is probing for whether garbage collection happens when it
 // shouldn't.  This will not in general be visible functionally, since
 // if GC runs twice in a row without any change to the store, the second
 // GC run will not do anything the first one didn't.  That's why this is
@@ skipping 35 matching lines @@
       },
       {
        "less_than_gc_thresh",
        // Few enough cookies that gc shouldn't happen at all.
        CookieMonster::kMaxCookies - 5,
        0,
       },
   };
   for (int ci = 0; ci < static_cast<int>(arraysize(test_cases)); ++ci) {
     const TestCase& test_case(test_cases[ci]);
-    scoped_ptr<CookieMonster> cm = CreateMonsterFromStoreForGC(
+    std::unique_ptr<CookieMonster> cm = CreateMonsterFromStoreForGC(
         test_case.num_cookies, test_case.num_old_cookies, 0, 0,
         CookieMonster::kSafeFromGlobalPurgeDays * 2);
 
     GURL gurl("http://google.com");
     std::string cookie_line("z=3");
     // Trigger the Garbage collection we're allowed.
     setCookieCallback.SetCookie(cm.get(), gurl, cookie_line);
 
     base::PerfTimeLogger timer((std::string("GC_") + test_case.name).c_str());
     for (int i = 0; i < kNumCookies; i++)
       setCookieCallback.SetCookie(cm.get(), gurl, cookie_line);
     timer.Done();
   }
 }
 
 }  // namespace net