content: Use stl utilities from the base namespace

content/browser/service_worker/service_worker_database_unittest.cc

 // Copyright 2014 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 "content/browser/service_worker/service_worker_database.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 375 matching lines @@
   std::vector<Resource> resources4;
   resources4.push_back(CreateResource(4, data4.script, 400));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data4, resources4, &deleted_version,
                                         &newly_purgeable_resources));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithRegistrations(&origins));
   EXPECT_EQ(3U, origins.size());
-  EXPECT_TRUE(ContainsKey(origins, origin1));
-  EXPECT_TRUE(ContainsKey(origins, origin2));
-  EXPECT_TRUE(ContainsKey(origins, origin3));
+  EXPECT_TRUE(base::ContainsKey(origins, origin1));
+  EXPECT_TRUE(base::ContainsKey(origins, origin2));
+  EXPECT_TRUE(base::ContainsKey(origins, origin3));
 
   // |origin3| has another registration, so should not remove it from the
   // unique origin list.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(data4.registration_id,
                                          origin3,
                                          &deleted_version,
                                          &newly_purgeable_resources));
   EXPECT_EQ(data4.registration_id, deleted_version.registration_id);
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithRegistrations(&origins));
   EXPECT_EQ(3U, origins.size());
-  EXPECT_TRUE(ContainsKey(origins, origin1));
-  EXPECT_TRUE(ContainsKey(origins, origin2));
-  EXPECT_TRUE(ContainsKey(origins, origin3));
+  EXPECT_TRUE(base::ContainsKey(origins, origin1));
+  EXPECT_TRUE(base::ContainsKey(origins, origin2));
+  EXPECT_TRUE(base::ContainsKey(origins, origin3));
 
   // |origin3| should be removed from the unique origin list.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(data3.registration_id,
                                          origin3,
                                          &deleted_version,
                                          &newly_purgeable_resources));
   EXPECT_EQ(data3.registration_id, deleted_version.registration_id);
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithRegistrations(&origins));
   EXPECT_EQ(2U, origins.size());
-  EXPECT_TRUE(ContainsKey(origins, origin1));
-  EXPECT_TRUE(ContainsKey(origins, origin2));
+  EXPECT_TRUE(base::ContainsKey(origins, origin1));
+  EXPECT_TRUE(base::ContainsKey(origins, origin2));
 }
 
 TEST(ServiceWorkerDatabaseTest, GetRegistrationsForOrigin) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin1("http://example.com");
   GURL origin2("https://www.example.com");
   GURL origin3("https://example.org");
 
   std::vector<RegistrationData> registrations;
@@ skipping 247 matching lines @@
   EXPECT_TRUE(resources_out.empty());
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
       database->ReadRegistrationOrigin(data.registration_id, &origin_out));
 
   // Resources should be purgeable because these are no longer referred.
   std::set<int64_t> purgeable_ids_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(2u, purgeable_ids_out.size());
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[0].resource_id));
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[1].resource_id));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, resources[0].resource_id));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, resources[1].resource_id));
 }
 
 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin("http://example.com");
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
@@ skipping 102 matching lines @@
   resources_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       updated_data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(updated_data, data_out);
   VerifyResourceRecords(resources2, resources_out);
 
   std::set<int64_t> purgeable_ids_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(2u, purgeable_ids_out.size());
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, resources1[0].resource_id));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 }
 
 TEST(ServiceWorkerDatabaseTest, Registration_Multiple) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   GURL origin("http://example.com");
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
 
   // Add registration1.
@@ skipping 72 matching lines @@
                 data1.registration_id, origin, &data_out, &resources_out));
   EXPECT_TRUE(resources_out.empty());
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
       database->ReadRegistrationOrigin(data1.registration_id, &origin_out));
 
   purgeable_ids_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(2u, purgeable_ids_out.size());
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, resources1[0].resource_id));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 
   // Make sure that registration2 is still alive.
   resources_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data2.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data2, data_out);
   VerifyResourceRecords(resources2, resources_out);
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->ReadRegistrationOrigin(data2.registration_id, &origin_out));
@@ skipping 626 matching lines @@
   origins_to_delete.insert(origin1);
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteAllDataForOrigins(origins_to_delete,
                                               &newly_purgeable_resources));
 
   // |origin1| should be removed from the unique origin list.
   std::set<GURL> unique_origins;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithRegistrations(&unique_origins));
   EXPECT_EQ(1u, unique_origins.size());
-  EXPECT_TRUE(ContainsKey(unique_origins, origin2));
+  EXPECT_TRUE(base::ContainsKey(unique_origins, origin2));
 
   // |origin1| should be removed from the foreign fetch origin list.
   unique_origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&unique_origins));
   EXPECT_EQ(1u, unique_origins.size());
-  EXPECT_TRUE(ContainsKey(unique_origins, origin2));
+  EXPECT_TRUE(base::ContainsKey(unique_origins, origin2));
 
   // The registrations for |origin1| should be removed.
   std::vector<RegistrationData> registrations;
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->GetRegistrationsForOrigin(origin1, &registrations, nullptr));
   EXPECT_TRUE(registrations.empty());
   GURL origin_out;
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
       database->ReadRegistrationOrigin(data1.registration_id, &origin_out));
 
   // The registration for |origin2| should not be removed.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data3.registration_id, origin2, &data_out, &resources_out));
   VerifyRegistrationData(data3, data_out);
   VerifyResourceRecords(resources3, resources_out);
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->ReadRegistrationOrigin(data3.registration_id, &origin_out));
   EXPECT_EQ(origin2, origin_out);
 
   // The resources associated with |origin1| should be purgeable.
   std::set<int64_t> purgeable_ids_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(4u, purgeable_ids_out.size());
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, 1));
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, 2));
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, 3));
-  EXPECT_TRUE(ContainsKey(purgeable_ids_out, 4));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, 1));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, 2));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, 3));
+  EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, 4));
 
   // The user data associated with |origin1| should be removed.
   std::vector<std::string> user_data_out;
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
       database->ReadUserData(data1.registration_id, {"key1"}, &user_data_out));
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
       database->ReadUserData(data1.registration_id, {"key2"}, &user_data_out));
   EXPECT_EQ(
@@ skipping 104 matching lines @@
   std::vector<Resource> resources5;
   resources5.push_back(CreateResource(5, data5.script, 500));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data5, resources5, &deleted_version,
                                         &newly_purgeable_resources));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&origins));
   EXPECT_EQ(2U, origins.size());
-  EXPECT_TRUE(ContainsKey(origins, origin1));
-  EXPECT_TRUE(ContainsKey(origins, origin3));
+  EXPECT_TRUE(base::ContainsKey(origins, origin1));
+  EXPECT_TRUE(base::ContainsKey(origins, origin3));
 
   // |origin3| has another registration, so should not remove it from the
   // foreign fetch origin list.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(data4.registration_id, origin3,
                                          &deleted_version,
                                          &newly_purgeable_resources));
   EXPECT_EQ(data4.registration_id, deleted_version.registration_id);
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&origins));
   EXPECT_EQ(2U, origins.size());
-  EXPECT_TRUE(ContainsKey(origins, origin1));
-  EXPECT_TRUE(ContainsKey(origins, origin3));
+  EXPECT_TRUE(base::ContainsKey(origins, origin1));
+  EXPECT_TRUE(base::ContainsKey(origins, origin3));
 
   // |origin3| should be removed from the foreign fetch origin list, since its
   // only remaining registration doesn't have foreign fetch scopes.
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(data3.registration_id, origin3,
                                          &deleted_version,
                                          &newly_purgeable_resources));
   EXPECT_EQ(data3.registration_id, deleted_version.registration_id);
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&origins));
   EXPECT_EQ(1U, origins.size());
-  EXPECT_TRUE(ContainsKey(origins, origin1));
+  EXPECT_TRUE(base::ContainsKey(origins, origin1));
 
   // |origin1| should be removed from the foreign fetch origin list, since we
   // replace its registration with one without scopes.
   RegistrationData updated_data1 = data1;
   updated_data1.version_id++;
   updated_data1.resources_total_size_bytes = 12 + 13;
   updated_data1.foreign_fetch_scopes.clear();
   std::vector<Resource> updated_resources1;
   updated_resources1.push_back(
       CreateResource(13, URL(origin1, "/resource3"), 12));
   updated_resources1.push_back(
       CreateResource(14, URL(origin1, "/resource4"), 13));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(updated_data1, updated_resources1,
                                         &deleted_version,
                                         &newly_purgeable_resources));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&origins));
   EXPECT_EQ(0U, origins.size());
 }
 
 }  // namespace content