c/browser, c/common, components O-P: Change ScopedTempDir::path() to GetPath()

components/omnibox/browser/in_memory_url_index_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <fstream>
 
@@ skipping 200 matching lines @@
       GetPrivateDataTracker());
 }
 
 bool InMemoryURLIndexTest::DeleteURL(const GURL& url) {
   return GetPrivateData()->DeleteURL(url);
 }
 
 void InMemoryURLIndexTest::SetUp() {
   // We cannot access the database until the backend has been loaded.
   if (history_dir_.CreateUniqueTempDir())
-    history_service_ = history::CreateHistoryService(history_dir_.path(), true);
+    history_service_ =
+        history::CreateHistoryService(history_dir_.GetPath(), true);
   ASSERT_TRUE(history_service_);
   BlockUntilInMemoryURLIndexIsRefreshed(url_index_.get());
 
   history::HistoryBackend* backend = history_service_->history_backend_.get();
   history_database_ = backend->db();
 
   // Create and populate a working copy of the URL history database.
   base::FilePath history_proto_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &history_proto_path);
   history_proto_path = history_proto_path.AppendASCII("components");
@@ skipping 796 matching lines @@
     const VisitInfoVector& visits = entry->second.visits;
     EXPECT_EQ(10u, visits.size());
     for (size_t i = 0; i < visits.size(); ++i)
       EXPECT_EQ(0, static_cast<int32_t>(visits[i].second));
   }
 }
 
 TEST_F(InMemoryURLIndexTest, CacheSaveRestore) {
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-  set_history_dir(temp_directory.path());
+  set_history_dir(temp_directory.GetPath());
 
   URLIndexPrivateData& private_data(*GetPrivateData());
 
   // Ensure that there is really something there to be saved.
   EXPECT_FALSE(private_data.word_list_.empty());
   // available_words_ will already be empty since we have freshly built the
   // data set for this test.
   EXPECT_TRUE(private_data.available_words_.empty());
   EXPECT_FALSE(private_data.word_map_.empty());
   EXPECT_FALSE(private_data.char_word_map_.empty());
@@ skipping 48 matching lines @@
   EXPECT_GT(new_data.restored_cache_version_, 0);
   EXPECT_EQ(rebuild_time, new_data.last_time_rebuilt_from_history_);
 
   // Compare the captured and restored for equality.
   ExpectPrivateDataEqual(*old_data.get(), new_data);
 }
 
 TEST_F(InMemoryURLIndexTest, RebuildFromHistoryIfCacheOld) {
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-  set_history_dir(temp_directory.path());
+  set_history_dir(temp_directory.GetPath());
 
   URLIndexPrivateData& private_data(*GetPrivateData());
 
   // Ensure that there is really something there to be saved.
   EXPECT_FALSE(private_data.word_list_.empty());
   // available_words_ will already be empty since we have freshly built the
   // data set for this test.
   EXPECT_TRUE(private_data.available_words_.empty());
   EXPECT_FALSE(private_data.word_map_.empty());
   EXPECT_FALSE(private_data.char_word_map_.empty());
@@ skipping 154 matching lines @@
   base::SequencedWorkerPoolOwner pool_owner_;
   base::ScopedTempDir temp_dir_;
   std::unique_ptr<InMemoryURLIndex> url_index_;
 };
 
 InMemoryURLIndexCacheTest::InMemoryURLIndexCacheTest()
     : pool_owner_(3, "Background Pool") {}
 
 void InMemoryURLIndexCacheTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-  base::FilePath path(temp_dir_.path());
+  base::FilePath path(temp_dir_.GetPath());
   url_index_.reset(new InMemoryURLIndex(nullptr, nullptr, nullptr,
                                         pool_owner_.pool().get(), path,
                                         SchemeSet()));
 }
 
 void InMemoryURLIndexCacheTest::TearDown() {
   if (url_index_)
     url_index_->Shutdown();
 }
 
 void InMemoryURLIndexCacheTest::set_history_dir(
     const base::FilePath& dir_path) {
   return url_index_->set_history_dir(dir_path);
 }
 
 bool InMemoryURLIndexCacheTest::GetCacheFilePath(
     base::FilePath* file_path) const {
   DCHECK(file_path);
   return url_index_->GetCacheFilePath(file_path);
 }
 
 TEST_F(InMemoryURLIndexCacheTest, CacheFilePath) {
   base::FilePath expectedPath =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("History Provider Cache"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("History Provider Cache"));
   std::vector<base::FilePath::StringType> expected_parts;
   expectedPath.GetComponents(&expected_parts);
   base::FilePath full_file_path;
   ASSERT_TRUE(GetCacheFilePath(&full_file_path));
   std::vector<base::FilePath::StringType> actual_parts;
   full_file_path.GetComponents(&actual_parts);
   ASSERT_EQ(expected_parts.size(), actual_parts.size());
   size_t count = expected_parts.size();
   for (size_t i = 0; i < count; ++i)
     EXPECT_EQ(expected_parts[i], actual_parts[i]);
   // Must clear the history_dir_ to satisfy the dtor's DCHECK.
   set_history_dir(base::FilePath());
 }