//chrome/browser and //components F-L: Change ScopedTempDir::path() to GetPath()

components/leveldb_proto/proto_database_impl_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 "components/leveldb_proto/proto_database_impl.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 422 matching lines @@
 
   base::Thread db_thread("dbthread");
   ASSERT_TRUE(db_thread.Start());
 
   std::unique_ptr<ProtoDatabaseImpl<TestProto>> db(
       new ProtoDatabaseImpl<TestProto>(db_thread.task_runner()));
 
   MockDatabaseCaller caller;
   EXPECT_CALL(caller, InitCallback(_));
   db->Init(
-      kTestLevelDBClientName, temp_dir.path(),
+      kTestLevelDBClientName, temp_dir.GetPath(),
       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 
   db.reset();
 
   base::RunLoop run_loop;
   db_thread.task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(base::DoNothing), run_loop.QuitClosure());
   run_loop.Run();
 }
 
 // This tests that normal usage of the real database does not cause any
 // threading violations.
 TEST(ProtoDatabaseImplThreadingTest, TestDBDestroy) {
   base::MessageLoop main_loop;
 
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   base::Thread db_thread("dbthread");
   ASSERT_TRUE(db_thread.Start());
 
   std::unique_ptr<ProtoDatabaseImpl<TestProto>> db(
       new ProtoDatabaseImpl<TestProto>(db_thread.task_runner()));
 
   MockDatabaseCaller caller;
   EXPECT_CALL(caller, InitCallback(_));
   db->Init(
-      kTestLevelDBClientName, temp_dir.path(),
+      kTestLevelDBClientName, temp_dir.GetPath(),
       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 
   EXPECT_CALL(caller, DestroyCallback(_));
   db->Destroy(base::Bind(&MockDatabaseCaller::DestroyCallback,
                          base::Unretained(&caller)));
 
   db.reset();
 
   base::RunLoop run_loop;
   db_thread.task_runner()->PostTaskAndReply(
@@ skipping 13 matching lines @@
   KeyValueVector save_entries;
   std::vector<std::string> load_entries;
   KeyVector remove_keys;
 
   for (const auto& pair : model) {
     save_entries.push_back(
         std::make_pair(pair.second.id(), pair.second.SerializeAsString()));
   }
 
   std::unique_ptr<LevelDB> db(new LevelDB(kTestLevelDBClientName));
-  EXPECT_TRUE(db->Init(temp_dir.path()));
+  EXPECT_TRUE(db->Init(temp_dir.GetPath()));
   EXPECT_TRUE(db->Save(save_entries, remove_keys));
 
   if (close_after_save) {
     db.reset(new LevelDB(kTestLevelDBClientName));
-    EXPECT_TRUE(db->Init(temp_dir.path()));
+    EXPECT_TRUE(db->Init(temp_dir.GetPath()));
   }
 
   EXPECT_TRUE(db->Load(&load_entries));
 
   // Convert the strings back to TestProto.
   std::vector<TestProto> loaded_protos;
   for (const auto& serialized_entry : load_entries) {
     TestProto entry;
     ASSERT_TRUE(entry.ParseFromString(serialized_entry));
     loaded_protos.push_back(entry);
@@ skipping 15 matching lines @@
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   leveldb::Options options;
   options.create_if_missing = false;
   std::unique_ptr<LevelDB> db(new LevelDB(kTestLevelDBClientName));
 
   KeyValueVector save_entries;
   std::vector<std::string> load_entries;
   KeyVector remove_keys;
 
-  EXPECT_FALSE(db->InitWithOptions(temp_dir.path(), options));
+  EXPECT_FALSE(db->InitWithOptions(temp_dir.GetPath(), options));
   EXPECT_FALSE(db->Load(&load_entries));
   EXPECT_FALSE(db->Save(save_entries, remove_keys));
 }
 
 TEST(ProtoDatabaseImplLevelDBTest, TestMemoryDatabase) {
   std::unique_ptr<LevelDB> db(new LevelDB(kTestLevelDBClientName));
 
   std::vector<std::string> load_entries;
 
   ASSERT_TRUE(db->Init(base::FilePath()));
 
   ASSERT_TRUE(db->Load(&load_entries));
   EXPECT_EQ(0u, load_entries.size());
 
   KeyValueVector save_entries(1, std::make_pair("foo", "bar"));
   KeyVector remove_keys;
 
   ASSERT_TRUE(db->Save(save_entries, remove_keys));
 
   std::vector<std::string> second_load_entries;
 
   ASSERT_TRUE(db->Load(&second_load_entries));
   EXPECT_EQ(1u, second_load_entries.size());
 }
 
 }  // namespace leveldb_proto