net: Use stl utilities from the base namespace

net/extras/sqlite/sqlite_persistent_cookie_store_unittest.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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 211 matching lines @@
   DestroyStore();
 
   // Load up the store and verify that it has good data in it.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("A", cookies[0]->Name().c_str());
   ASSERT_STREQ("B", cookies[0]->Value().c_str());
   DestroyStore();
-  STLDeleteElements(&cookies);
+  base::STLDeleteElements(&cookies);
 
   // Now corrupt the meta table.
   {
     sql::Connection db;
     ASSERT_TRUE(db.Open(temp_dir_.path().Append(kCookieFilename)));
     sql::MetaTable meta_table_;
     meta_table_.Init(&db, 1, 1);
     ASSERT_TRUE(db.Execute("DELETE FROM meta"));
     db.Close();
   }
 
   // Upon loading, the database should be reset to a good, blank state.
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 
   // Verify that, after, recovery, the database persists properly.
   AddCookie(GURL("http://foo.bar"), "X", "Y", std::string(), "/",
             base::Time::Now());
   DestroyStore();
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("X", cookies[0]->Name().c_str());
   ASSERT_STREQ("Y", cookies[0]->Value().c_str());
-  STLDeleteElements(&cookies);
+  base::STLDeleteElements(&cookies);
 }
 
 // Test if data is stored as expected in the SQLite database.
 TEST_F(SQLitePersistentCookieStoreTest, TestPersistance) {
   InitializeStore(false, false);
   AddCookie(GURL("http://foo.bar"), "A", "B", std::string(), "/",
             base::Time::Now());
   // Replace the store effectively destroying the current one and forcing it
   // to write its data to disk. Then we can see if after loading it again it
   // is still there.
   DestroyStore();
   // Reload and test for persistence
   CanonicalCookieVector cookies;
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("A", cookies[0]->Name().c_str());
   ASSERT_STREQ("B", cookies[0]->Value().c_str());
 
   // Now delete the cookie and check persistence again.
   store_->DeleteCookie(*cookies[0]);
   DestroyStore();
-  STLDeleteElements(&cookies);
+  base::STLDeleteElements(&cookies);
 
   // Reload and check if the cookie has been removed.
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, TestSessionCookiesDeletedOnStartup) {
   // Initialize the cookie store with 3 persistent cookies, 5 transient
   // cookies.
   InitializeStore(false, false);
@@ skipping 48 matching lines @@
   // Now the DB-thread queue contains:
   // (active:)
   // 1. Wait (on db_event)
   // (pending:)
   // 2. "Init And Chain-Load First Domain"
   // 3. Add Cookie (c.com)
   // 4. Flush Cookie (c.com)
   db_thread_event_.Signal();
   event.Wait();
   loaded_event_.Wait();
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
   DestroyStore();
 
   // Load the store a third time, this time restoring session cookies. The
   // store should contain exactly 4 cookies: the 3 persistent, and "c.com",
   // which was added during the second cookie store load.
   store_ = new SQLitePersistentCookieStore(
       temp_dir_.path().Append(kCookieFilename), client_task_runner(),
       background_task_runner(), true, nullptr);
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   loaded_event_.Wait();
   ASSERT_EQ(4u, cookies_.size());
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
 }
 
 // Test that priority load of cookies for a specfic domain key could be
 // completed before the entire store is loaded
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadCookiesForKey) {
   InitializeStore(false, false);
   base::Time t = base::Time::Now();
   AddCookie(GURL("http://foo.bar"), "A", "B", std::string(), "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie(GURL("http://www.aaa.com"), "A", "B", std::string(), "/", t);
@@ skipping 29 matching lines @@
   // 3. Priority Load (aaa.com)
   // 4. Wait (on db_event)
   db_thread_event_.Signal();
   key_loaded_event_.Wait();
   ASSERT_EQ(loaded_event_.IsSignaled(), false);
   std::set<std::string> cookies_loaded;
   for (CanonicalCookieVector::const_iterator it = cookies_.begin();
        it != cookies_.end(); ++it) {
     cookies_loaded.insert((*it)->Domain().c_str());
   }
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
   ASSERT_GT(4U, cookies_loaded.size());
   ASSERT_EQ(true, cookies_loaded.find("www.aaa.com") != cookies_loaded.end());
   ASSERT_EQ(true,
             cookies_loaded.find("travel.aaa.com") != cookies_loaded.end());
 
   db_thread_event_.Signal();
   loaded_event_.Wait();
   for (CanonicalCookieVector::const_iterator it = cookies_.begin();
        it != cookies_.end(); ++it) {
     cookies_loaded.insert((*it)->Domain().c_str());
   }
   ASSERT_EQ(4U, cookies_loaded.size());
   ASSERT_EQ(cookies_loaded.find("foo.bar") != cookies_loaded.end(), true);
   ASSERT_EQ(cookies_loaded.find("www.bbb.com") != cookies_loaded.end(), true);
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
 }
 
 // Test that we can force the database to be written by calling Flush().
 TEST_F(SQLitePersistentCookieStoreTest, TestFlush) {
   InitializeStore(false, false);
   // File timestamps don't work well on all platforms, so we'll determine
   // whether the DB file has been modified by checking its size.
   base::FilePath path = temp_dir_.path().Append(kCookieFilename);
   base::File::Info info;
   ASSERT_TRUE(base::GetFileInfo(path, &info));
@@ skipping 32 matching lines @@
   // was loaded.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, true, &cookies);
 
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("sessioncookie.com", cookies[0]->Domain().c_str());
   ASSERT_STREQ("C", cookies[0]->Name().c_str());
   ASSERT_STREQ("D", cookies[0]->Value().c_str());
   ASSERT_EQ(COOKIE_PRIORITY_DEFAULT, cookies[0]->Priority());
 
-  STLDeleteElements(&cookies);
+  base::STLDeleteElements(&cookies);
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestDontLoadOldSessionCookies) {
   InitializeStore(false, true);
 
   // Add a session cookie.
   store_->AddCookie(*CanonicalCookie::Create(
       GURL("http://sessioncookie.com"), "C", "D", std::string(), "/",
       base::Time::Now(), base::Time(), false, false,
@@ skipping 52 matching lines @@
 
   std::map<std::string, CanonicalCookie*>::const_iterator it =
       cookie_map.find(kSessionName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_FALSE(cookie_map[kSessionName]->IsPersistent());
 
   it = cookie_map.find(kPersistentName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_TRUE(cookie_map[kPersistentName]->IsPersistent());
 
-  STLDeleteElements(&cookies);
+  base::STLDeleteElements(&cookies);
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, PriorityIsPersistent) {
   static const char kURL[] = "http://sessioncookie.com";
   static const char kLowName[] = "low";
   static const char kMediumName[] = "medium";
   static const char kHighName[] = "high";
   static const char kCookieValue[] = "value";
   static const char kCookiePath[] = "/";
 
@@ skipping 43 matching lines @@
   EXPECT_EQ(COOKIE_PRIORITY_LOW, cookie_map[kLowName]->Priority());
 
   it = cookie_map.find(kMediumName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_EQ(COOKIE_PRIORITY_MEDIUM, cookie_map[kMediumName]->Priority());
 
   it = cookie_map.find(kHighName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_EQ(COOKIE_PRIORITY_HIGH, cookie_map[kHighName]->Priority());
 
-  STLDeleteElements(&cookies);
+  base::STLDeleteElements(&cookies);
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, SameSiteIsPersistent) {
   const char kURL[] = "http://sessioncookie.com";
   const char kNoneName[] = "none";
   const char kLaxName[] = "lax";
   const char kStrictName[] = "strict";
   const char kCookieValue[] = "value";
   const char kCookiePath[] = "/";
 
@@ skipping 37 matching lines @@
   // Validate that each cookie has the correct SameSite.
   ASSERT_EQ(1u, cookie_map.count(kNoneName));
   EXPECT_EQ(CookieSameSite::NO_RESTRICTION, cookie_map[kNoneName]->SameSite());
 
   ASSERT_EQ(1u, cookie_map.count(kLaxName));
   EXPECT_EQ(CookieSameSite::LAX_MODE, cookie_map[kLaxName]->SameSite());
 
   ASSERT_EQ(1u, cookie_map.count(kStrictName));
   EXPECT_EQ(CookieSameSite::STRICT_MODE, cookie_map[kStrictName]->SameSite());
 
-  STLDeleteElements(&cookies);
+  base::STLDeleteElements(&cookies);
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, UpdateToEncryption) {
   CanonicalCookieVector cookies;
 
   // Create unencrypted cookie store and write something to it.
   InitializeStore(false, false);
   AddCookie(GURL("http://foo.bar"), "name", "value123XYZ", std::string(), "/",
             base::Time::Now());
   DestroyStore();
 
   // Verify that "value" is visible in the file.  This is necessary in order to
   // have confidence in a later test that "encrypted_value" is not visible.
   std::string contents = ReadRawDBContents();
   EXPECT_NE(0U, contents.length());
   EXPECT_NE(contents.find("value123XYZ"), std::string::npos);
 
   // Create encrypted cookie store and ensure old cookie still reads.
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
   EXPECT_EQ(0U, cookies_.size());
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(1U, cookies_.size());
   EXPECT_EQ("name", cookies_[0]->Name());
   EXPECT_EQ("value123XYZ", cookies_[0]->Value());
 
   // Make sure we can update existing cookie and add new cookie as encrypted.
   store_->DeleteCookie(*(cookies_[0]));
   AddCookie(GURL("http://foo.bar"), "name", "encrypted_value123XYZ",
             std::string(), "/", base::Time::Now());
   AddCookie(GURL("http://foo.bar"), "other", "something456ABC", std::string(),
             "/", base::Time::Now() + base::TimeDelta::FromInternalValue(10));
   DestroyStore();
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(2U, cookies_.size());
   CanonicalCookie* cookie_name = nullptr;
   CanonicalCookie* cookie_other = nullptr;
   if (cookies_[0]->Name() == "name") {
     cookie_name = cookies_[0];
     cookie_other = cookies_[1];
   } else {
     cookie_name = cookies_[1];
     cookie_other = cookies_[0];
   }
   EXPECT_EQ("encrypted_value123XYZ", cookie_name->Value());
   EXPECT_EQ("something456ABC", cookie_other->Value());
   DestroyStore();
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
 
   // Examine the real record to make sure plaintext version doesn't exist.
   sql::Connection db;
   sql::Statement smt;
   int resultcount = 0;
   ASSERT_TRUE(db.Open(temp_dir_.path().Append(kCookieFilename)));
   smt.Assign(db.GetCachedStatement(SQL_FROM_HERE,
                                    "SELECT * "
                                    "FROM cookies "
                                    "WHERE host_key = 'foo.bar'"));
@@ skipping 21 matching lines @@
   AddCookie(GURL("http://foo.bar"), "name", "value123XYZ", std::string(), "/",
             base::Time::Now());
   DestroyStore();
 
   // Verify that "value" is not visible in the file.
   std::string contents = ReadRawDBContents();
   EXPECT_NE(0U, contents.length());
   EXPECT_EQ(contents.find("value123XYZ"), std::string::npos);
 
   // Create encrypted cookie store and ensure old cookie still reads.
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
   EXPECT_EQ(0U, cookies_.size());
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(1U, cookies_.size());
   EXPECT_EQ("name", cookies_[0]->Name());
   EXPECT_EQ("value123XYZ", cookies_[0]->Value());
 
   // Make sure we can update existing cookie and it writes unencrypted.
   cookie_crypto_delegate_->should_encrypt_ = false;
   store_->DeleteCookie(*(cookies_[0]));
   AddCookie(GURL("http://foo.bar"), "name", "plaintext_value123XYZ",
             std::string(), "/", base::Time::Now());
   AddCookie(GURL("http://foo.bar"), "other", "something456ABC", std::string(),
             "/", base::Time::Now() + base::TimeDelta::FromInternalValue(10));
   DestroyStore();
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(2U, cookies_.size());
   CanonicalCookie* cookie_name = nullptr;
   CanonicalCookie* cookie_other = nullptr;
   if (cookies_[0]->Name() == "name") {
     cookie_name = cookies_[0];
     cookie_other = cookies_[1];
   } else {
     cookie_name = cookies_[1];
     cookie_other = cookies_[0];
   }
   EXPECT_EQ("plaintext_value123XYZ", cookie_name->Value());
   EXPECT_EQ("something456ABC", cookie_other->Value());
   DestroyStore();
-  STLDeleteElements(&cookies_);
+  base::STLDeleteElements(&cookies_);
 
   // Verify that "value" is now visible in the file.
   contents = ReadRawDBContents();
   EXPECT_NE(0U, contents.length());
   EXPECT_NE(contents.find("value123XYZ"), std::string::npos);
 }
 
 namespace {
 void WasCalledWithNoCookies(bool* was_called_with_no_cookies,
                             const std::vector<CanonicalCookie*>& cookies) {
@@ skipping 19 matching lines @@
   EXPECT_TRUE(was_called_with_no_cookies);
 
   // Same with trying to load a specific cookie.
   was_called_with_no_cookies = false;
   store_->LoadCookiesForKey("foo.bar", base::Bind(WasCalledWithNoCookies,
                                                   &was_called_with_no_cookies));
   EXPECT_TRUE(was_called_with_no_cookies);
 }
 
 }  // namespace net