//content: Change ScopedTempDir::path() to GetPath()

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 72 matching lines @@
     EXPECT_EQ(expected[i].size_bytes, actual[i].size_bytes);
   }
 }
 
 }  // namespace
 
 TEST(ServiceWorkerDatabaseTest, OpenDatabase) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   std::unique_ptr<ServiceWorkerDatabase> database(
-      CreateDatabase(database_dir.path()));
+      CreateDatabase(database_dir.GetPath()));
 
   // Should be false because the database does not exist at the path.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->LazyOpen(false));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
 
-  database.reset(CreateDatabase(database_dir.path()));
+  database.reset(CreateDatabase(database_dir.GetPath()));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(false));
 }
 
 TEST(ServiceWorkerDatabaseTest, OpenDatabase_InMemory) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   // Should be false because the database does not exist in memory.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->LazyOpen(false));
 
@@ skipping 31 matching lines @@
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadDatabaseVersion(&db_version));
   EXPECT_LT(0, db_version);
 }
 
 TEST(ServiceWorkerDatabaseTest, DatabaseVersion_ObsoleteSchemaVersion) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   std::unique_ptr<ServiceWorkerDatabase> database(
-      CreateDatabase(database_dir.path()));
+      CreateDatabase(database_dir.GetPath()));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
 
   // First writing triggers database initialization and bumps the schema
   // version.
   GURL origin("http://example.com");
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   resources.push_back(CreateResource(1, URL(origin, "/resource"), 10));
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
   ServiceWorkerDatabase::RegistrationData data;
@@ skipping 10 matching lines @@
   int64_t old_db_version = 1;
   leveldb::WriteBatch batch;
   batch.Put("INITDATA_DB_VERSION", base::Int64ToString(old_db_version));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, database->WriteBatch(&batch));
   db_version = -1;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadDatabaseVersion(&db_version));
   ASSERT_EQ(old_db_version, db_version);
 
   // Opening the database whose schema version is obsolete should fail.
-  database.reset(CreateDatabase(database_dir.path()));
+  database.reset(CreateDatabase(database_dir.GetPath()));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_FAILED,
             database->LazyOpen(true));
 }
 
 TEST(ServiceWorkerDatabaseTest, DatabaseVersion_CorruptedSchemaVersion) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   std::unique_ptr<ServiceWorkerDatabase> database(
-      CreateDatabase(database_dir.path()));
+      CreateDatabase(database_dir.GetPath()));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
 
   // First writing triggers database initialization and bumps the schema
   // version.
   GURL origin("http://example.com");
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   resources.push_back(CreateResource(1, URL(origin, "/resource"), 10));
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
   ServiceWorkerDatabase::RegistrationData data;
   data.resources_total_size_bytes = 10;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data, resources, &deleted_version,
                                         &newly_purgeable_resources));
   int64_t db_version = -1;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadDatabaseVersion(&db_version));
   ASSERT_LT(0, db_version);
 
   // Emulate a corrupted schema version.
   int64_t corrupted_db_version = -10;
   leveldb::WriteBatch batch;
   batch.Put("INITDATA_DB_VERSION", base::Int64ToString(corrupted_db_version));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, database->WriteBatch(&batch));
   db_version = -1;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED,
             database->ReadDatabaseVersion(&db_version));
 
   // Opening the database whose schema version is corrupted should fail.
-  database.reset(CreateDatabase(database_dir.path()));
+  database.reset(CreateDatabase(database_dir.GetPath()));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED,
             database->LazyOpen(true));
 }
 
 TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   std::unique_ptr<ServiceWorkerDatabase> database(
-      CreateDatabase(database_dir.path()));
+      CreateDatabase(database_dir.GetPath()));
 
   GURL origin("http://example.com");
 
   // The database has never been used, so returns initial values.
   AvailableIds ids;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
       &ids.reg_id, &ids.ver_id, &ids.res_id));
   EXPECT_EQ(0, ids.reg_id);
   EXPECT_EQ(0, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
@@ skipping 67 matching lines @@
             database->WriteRegistration(data2, resources2, &deleted_version,
                                         &newly_purgeable_resources));
 
   // Same with resources.
   int64_t kLowResourceId = 15;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteUncommittedResourceIds(
                 std::set<int64_t>(&kLowResourceId, &kLowResourceId + 1)));
 
   // Close and reopen the database to verify the stored values.
-  database.reset(CreateDatabase(database_dir.path()));
+  database.reset(CreateDatabase(database_dir.GetPath()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
       &ids.reg_id, &ids.ver_id, &ids.res_id));
   EXPECT_EQ(101, ids.reg_id);
   EXPECT_EQ(201, ids.ver_id);
   EXPECT_EQ(21, ids.res_id);
 }
 
 TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
@@ skipping 1297 matching lines @@
       ServiceWorkerDatabase::STATUS_OK,
       database->ReadUserData(data3.registration_id, {"key6"}, &user_data_out));
   ASSERT_EQ(1u, user_data_out.size());
   EXPECT_EQ("data6", user_data_out[0]);
 }
 
 TEST(ServiceWorkerDatabaseTest, DestroyDatabase) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   std::unique_ptr<ServiceWorkerDatabase> database(
-      CreateDatabase(database_dir.path()));
+      CreateDatabase(database_dir.GetPath()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
-  ASSERT_TRUE(base::DirectoryExists(database_dir.path()));
+  ASSERT_TRUE(base::DirectoryExists(database_dir.GetPath()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase());
-  ASSERT_FALSE(base::DirectoryExists(database_dir.path()));
+  ASSERT_FALSE(base::DirectoryExists(database_dir.GetPath()));
 }
 
 TEST(ServiceWorkerDatabaseTest, GetOriginsWithForeignFetchRegistrations) {
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   std::set<GURL> origins;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&origins));
   EXPECT_TRUE(origins.empty());
 
@@ skipping 119 matching lines @@
                                         &deleted_version,
                                         &newly_purgeable_resources));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithForeignFetchRegistrations(&origins));
   EXPECT_EQ(0U, origins.size());
 }
 
 }  // namespace content