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

content/browser/indexed_db/indexed_db_factory_unittest.cc

 // Copyright 2013 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 <stdint.h>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
@@ skipping 85 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(IndexedDBFactoryTest);
 };
 
 TEST_F(IndexedDBFactoryTest, BackingStoreLifetime) {
   const Origin origin1(GURL("http://localhost:81"));
   const Origin origin2(GURL("http://localhost:82"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   scoped_refptr<IndexedDBBackingStore> disk_store1 =
-      factory()->TestOpenBackingStore(origin1, temp_directory.path());
+      factory()->TestOpenBackingStore(origin1, temp_directory.GetPath());
 
   scoped_refptr<IndexedDBBackingStore> disk_store2 =
-      factory()->TestOpenBackingStore(origin1, temp_directory.path());
+      factory()->TestOpenBackingStore(origin1, temp_directory.GetPath());
   EXPECT_EQ(disk_store1.get(), disk_store2.get());
 
   scoped_refptr<IndexedDBBackingStore> disk_store3 =
-      factory()->TestOpenBackingStore(origin2, temp_directory.path());
+      factory()->TestOpenBackingStore(origin2, temp_directory.GetPath());
 
   factory()->TestCloseBackingStore(disk_store1.get());
   factory()->TestCloseBackingStore(disk_store3.get());
 
   EXPECT_FALSE(disk_store1->HasOneRef());
   EXPECT_FALSE(disk_store2->HasOneRef());
   EXPECT_TRUE(disk_store3->HasOneRef());
 
   disk_store2 = nullptr;
   EXPECT_TRUE(disk_store1->HasOneRef());
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreLazyClose) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   scoped_refptr<IndexedDBBackingStore> store =
-      factory()->TestOpenBackingStore(origin, temp_directory.path());
+      factory()->TestOpenBackingStore(origin, temp_directory.GetPath());
 
   // Give up the local refptr so that the factory has the only
   // outstanding reference.
   IndexedDBBackingStore* store_ptr = store.get();
   store = nullptr;
   EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
   factory()->TestReleaseBackingStore(store_ptr, false);
   EXPECT_TRUE(store_ptr->close_timer()->IsRunning());
 
-  factory()->TestOpenBackingStore(origin, temp_directory.path());
+  factory()->TestOpenBackingStore(origin, temp_directory.GetPath());
   EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
   factory()->TestReleaseBackingStore(store_ptr, false);
   EXPECT_TRUE(store_ptr->close_timer()->IsRunning());
 
   // Take back a ref ptr and ensure that the actual close
   // stops a running timer.
   store = store_ptr;
   factory()->TestCloseBackingStore(store_ptr);
   EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
 }
@@ skipping 24 matching lines @@
   EXPECT_FALSE(mem_store2->HasOneRef());  // mem_store1 and 2
   EXPECT_TRUE(mem_store3->HasOneRef());
 
   mem_store2 = nullptr;
   EXPECT_TRUE(mem_store1->HasOneRef());
 }
 
 TEST_F(IndexedDBFactoryTest, RejectLongOrigins) {
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-  const base::FilePath base_path = temp_directory.path();
+  const base::FilePath base_path = temp_directory.GetPath();
 
   int limit = base::GetMaximumPathComponentLength(base_path);
   EXPECT_GT(limit, 0);
 
   std::string origin(limit + 1, 'x');
   Origin too_long_origin(GURL("http://" + origin + ":81/"));
   scoped_refptr<IndexedDBBackingStore> diskStore1 =
       factory()->TestOpenBackingStore(too_long_origin, base_path);
   EXPECT_FALSE(diskStore1.get());
 
@@ skipping 53 matching lines @@
   scoped_refptr<LookingForQuotaErrorMockCallbacks> callbacks =
       new LookingForQuotaErrorMockCallbacks;
   scoped_refptr<IndexedDBDatabaseCallbacks> dummy_database_callbacks =
       new IndexedDBDatabaseCallbacks(nullptr, 0, 0);
   const base::string16 name(ASCIIToUTF16("name"));
   std::unique_ptr<IndexedDBPendingConnection> connection(
       base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, dummy_database_callbacks, 0 /* child_process_id */,
           2 /* transaction_id */, 1 /* version */));
   factory->Open(name, std::move(connection), nullptr /* request_context */,
-                origin, temp_directory.path());
+                origin, temp_directory.GetPath());
   EXPECT_TRUE(callbacks->error_called());
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreReleasedOnForcedClose) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64_t transaction_id = 1;
   std::unique_ptr<IndexedDBPendingConnection> connection(
       base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
           IndexedDBDatabaseMetadata::DEFAULT_VERSION));
   factory()->Open(ASCIIToUTF16("db"), std::move(connection),
-                  nullptr /* request_context */, origin, temp_directory.path());
+                  nullptr /* request_context */, origin,
+                  temp_directory.GetPath());
 
   EXPECT_TRUE(callbacks->connection());
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 
   callbacks->connection()->ForceClose();
 
   EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreReleaseDelayedOnClose) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64_t transaction_id = 1;
   std::unique_ptr<IndexedDBPendingConnection> connection(
       base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
           IndexedDBDatabaseMetadata::DEFAULT_VERSION));
   factory()->Open(ASCIIToUTF16("db"), std::move(connection),
-                  nullptr /* request_context */, origin, temp_directory.path());
+                  nullptr /* request_context */, origin,
+                  temp_directory.GetPath());
 
   EXPECT_TRUE(callbacks->connection());
   IndexedDBBackingStore* store =
       callbacks->connection()->database()->backing_store();
   EXPECT_FALSE(store->HasOneRef());  // Factory and database.
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   callbacks->connection()->Close();
   EXPECT_TRUE(store->HasOneRef());  // Factory.
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
@@ skipping 15 matching lines @@
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
 
   const bool expect_connection = false;
   scoped_refptr<MockIndexedDBCallbacks> callbacks(
       new MockIndexedDBCallbacks(expect_connection));
   factory()->DeleteDatabase(ASCIIToUTF16("db"), nullptr /* request_context */,
-                            callbacks, origin, temp_directory.path());
+                            callbacks, origin, temp_directory.GetPath());
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_TRUE(factory()->IsBackingStorePendingClose(origin));
 
   // Now simulate shutdown, which should stop the timer.
   factory()->ContextDestroyed();
 
   EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 }
 
 TEST_F(IndexedDBFactoryTest, GetDatabaseNamesClosesBackingStore) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
 
   const bool expect_connection = false;
   scoped_refptr<MockIndexedDBCallbacks> callbacks(
       new MockIndexedDBCallbacks(expect_connection));
-  factory()->GetDatabaseNames(callbacks, origin, temp_directory.path(),
+  factory()->GetDatabaseNames(callbacks, origin, temp_directory.GetPath(),
                               nullptr /* request_context */);
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_TRUE(factory()->IsBackingStorePendingClose(origin));
 
   // Now simulate shutdown, which should stop the timer.
   factory()->ContextDestroyed();
 
   EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 }
 
 TEST_F(IndexedDBFactoryTest, ForceCloseReleasesBackingStore) {
   const Origin origin(GURL("http://localhost:81"));
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64_t transaction_id = 1;
   std::unique_ptr<IndexedDBPendingConnection> connection(
       base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
           IndexedDBDatabaseMetadata::DEFAULT_VERSION));
   factory()->Open(ASCIIToUTF16("db"), std::move(connection),
-                  nullptr /* request_context */, origin, temp_directory.path());
+                  nullptr /* request_context */, origin,
+                  temp_directory.GetPath());
 
   EXPECT_TRUE(callbacks->connection());
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
 
   callbacks->connection()->Close();
 
   EXPECT_TRUE(factory()->IsBackingStoreOpen(origin));
   EXPECT_TRUE(factory()->IsBackingStorePendingClose(origin));
 
@@ skipping 61 matching lines @@
   // Open at version 2, then close.
   {
     scoped_refptr<MockIndexedDBCallbacks> callbacks(
         new UpgradeNeededCallbacks());
     std::unique_ptr<IndexedDBPendingConnection> connection(
         base::MakeUnique<IndexedDBPendingConnection>(
             callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
             db_version));
     factory()->Open(db_name, std::move(connection),
                     nullptr /* request_context */, origin,
-                    temp_directory.path());
+                    temp_directory.GetPath());
     EXPECT_TRUE(factory()->IsDatabaseOpen(origin, db_name));
 
     // Pump the message loop so the upgrade transaction can run.
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(callbacks->connection());
     callbacks->connection()->database()->Commit(transaction_id);
 
     callbacks->connection()->Close();
     EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
   }
 
   // Open at version < 2, which will fail; ensure factory doesn't retain
   // the database object.
   {
     scoped_refptr<ErrorCallbacks> callbacks(new ErrorCallbacks());
     std::unique_ptr<IndexedDBPendingConnection> connection(
         base::MakeUnique<IndexedDBPendingConnection>(
             callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
             db_version - 1));
     factory()->Open(db_name, std::move(connection),
                     nullptr /* request_context */, origin,
-                    temp_directory.path());
+                    temp_directory.GetPath());
     EXPECT_TRUE(callbacks->saw_error());
     EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
   }
 
   // Terminate all pending-close timers.
   factory()->ForceClose(origin);
 }
 
 }  // namespace content