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

content/browser/notifications/notification_database_unittest.cc

 // Copyright 2015 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/notifications/notification_database.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/files/scoped_temp_dir.h"
@@ skipping 110 matching lines @@
 
   EXPECT_EQ(NotificationDatabase::STATUS_ERROR_NOT_FOUND,
             database->Open(false /* create_if_missing */));
 }
 
 TEST_F(NotificationDatabaseTest, OpenCloseFileSystem) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 
   std::unique_ptr<NotificationDatabase> database(
-      CreateDatabaseOnFileSystem(database_dir.path()));
+      CreateDatabaseOnFileSystem(database_dir.GetPath()));
 
   // Should return false because the database does not exist on the file system.
   EXPECT_EQ(NotificationDatabase::STATUS_ERROR_NOT_FOUND,
             database->Open(false /* create_if_missing */));
 
   // Should return true, indicating that the database could be created.
   EXPECT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   EXPECT_TRUE(IsDatabaseOpen(database.get()));
   EXPECT_FALSE(IsInMemoryDatabase(database.get()));
 
   // Close the database, and re-open it without attempting to create it because
   // the files on the file system should still exist as expected.
-  database.reset(CreateDatabaseOnFileSystem(database_dir.path()));
+  database.reset(CreateDatabaseOnFileSystem(database_dir.GetPath()));
   EXPECT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(false /* create_if_missing */));
 }
 
 TEST_F(NotificationDatabaseTest, DestroyDatabase) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 
   std::unique_ptr<NotificationDatabase> database(
-      CreateDatabaseOnFileSystem(database_dir.path()));
+      CreateDatabaseOnFileSystem(database_dir.GetPath()));
 
   EXPECT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
   EXPECT_TRUE(IsDatabaseOpen(database.get()));
 
   // Destroy the database. This will immediately close it as well.
   ASSERT_EQ(NotificationDatabase::STATUS_OK, database->Destroy());
   EXPECT_FALSE(IsDatabaseOpen(database.get()));
 
   // Try to re-open the database (but not re-create it). This should fail as
   // the files associated with the database should have been blown away.
-  database.reset(CreateDatabaseOnFileSystem(database_dir.path()));
+  database.reset(CreateDatabaseOnFileSystem(database_dir.GetPath()));
   EXPECT_EQ(NotificationDatabase::STATUS_ERROR_NOT_FOUND,
             database->Open(false /* create_if_missing */));
 }
 
 TEST_F(NotificationDatabaseTest, NotificationIdIncrements) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 
   std::unique_ptr<NotificationDatabase> database(
-      CreateDatabaseOnFileSystem(database_dir.path()));
+      CreateDatabaseOnFileSystem(database_dir.GetPath()));
 
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   GURL origin("https://example.com");
 
   int64_t notification_id = 0;
 
   // Verify that getting two ids on the same database instance results in
   // incrementing values. Notification ids will start at 1.
   ASSERT_NO_FATAL_FAILURE(
       CreateAndWriteNotification(database.get(), origin, "" /* tag */,
                                  0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 1);
 
   ASSERT_NO_FATAL_FAILURE(
       CreateAndWriteNotification(database.get(), origin, "" /* tag */,
                                  0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 2);
 
-  database.reset(CreateDatabaseOnFileSystem(database_dir.path()));
+  database.reset(CreateDatabaseOnFileSystem(database_dir.GetPath()));
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(false /* create_if_missing */));
 
   // Verify that the next notification id was stored in the database, and
   // continues where we expect it to be, even after closing and opening it.
   ASSERT_NO_FATAL_FAILURE(
       CreateAndWriteNotification(database.get(), origin, "" /* tag */,
                                  0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 3);
 }
@@ skipping 18 matching lines @@
       database->ReadNotificationData(notification_id, origin, &database_data));
 
   EXPECT_EQ(notification_id, database_data.notification_id);
 }
 
 TEST_F(NotificationDatabaseTest, NotificationIdCorruption) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 
   std::unique_ptr<NotificationDatabase> database(
-      CreateDatabaseOnFileSystem(database_dir.path()));
+      CreateDatabaseOnFileSystem(database_dir.GetPath()));
 
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   GURL origin("https://example.com");
 
   NotificationDatabaseData database_data;
   int64_t notification_id = 0;
 
   ASSERT_EQ(
       NotificationDatabase::STATUS_OK,
       database->WriteNotificationData(origin, database_data, &notification_id));
   EXPECT_EQ(notification_id, 1);
 
   // Deliberately write an invalid value as the next notification id. When
   // re-opening the database, the Open() method should realize that an invalid
   // value is being read, and mark the database as corrupted.
   ASSERT_NO_FATAL_FAILURE(
       WriteLevelDBKeyValuePair(database.get(), "NEXT_NOTIFICATION_ID", "-42"));
 
-  database.reset(CreateDatabaseOnFileSystem(database_dir.path()));
+  database.reset(CreateDatabaseOnFileSystem(database_dir.GetPath()));
   EXPECT_EQ(NotificationDatabase::STATUS_ERROR_CORRUPTED,
             database->Open(false /* create_if_missing */));
 }
 
 TEST_F(NotificationDatabaseTest, ReadInvalidNotificationData) {
   std::unique_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   NotificationDatabaseData database_data;
@@ skipping 362 matching lines @@
 
   std::vector<NotificationDatabaseData> notifications;
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->ReadAllNotificationDataForServiceWorkerRegistration(
                 origin, kExampleServiceWorkerRegistrationId, &notifications));
 
   EXPECT_EQ(0u, notifications.size());
 }
 
 }  // namespace content