installer and some misc files: Change ScopedTempDir::path() to GetPath()

components/browser_watcher/postmortem_report_collector_unittest.cc

 // Copyright 2016 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/browser_watcher/postmortem_report_collector.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <set>
@@ skipping 124 matching lines @@
 }
 
 }  // namespace
 
 class PostmortemReportCollectorCollectAndSubmitTest : public testing::Test {
  public:
   void SetUp() override {
     testing::Test::SetUp();
     // Create a dummy debug file.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    debug_file_ = temp_dir_.path().AppendASCII("foo-1.pma");
+    debug_file_ = temp_dir_.GetPath().AppendASCII("foo-1.pma");
     {
       base::ScopedFILE file(base::OpenFile(debug_file_, "w"));
       ASSERT_NE(file.get(), nullptr);
     }
     ASSERT_TRUE(base::PathExists(debug_file_));
 
     // Expect collection of the debug file paths.
     debug_file_pattern_ = FILE_PATH_LITERAL("foo-*.pma");
     std::vector<base::FilePath> debug_files{debug_file_};
     EXPECT_CALL(collector_,
                 GetDebugStateFilePaths(debug_file_.DirName(),
                                        debug_file_pattern_, no_excluded_files_))
         .Times(1)
         .WillOnce(Return(debug_files));
 
     EXPECT_CALL(database_, GetSettings()).Times(1).WillOnce(Return(nullptr));
 
     // Expect collection to a proto of a single debug file.
     // Note: caller takes ownership.
     StabilityReport* stability_report = new StabilityReport();
     EXPECT_CALL(collector_, CollectRaw(debug_file_))
         .Times(1)
         .WillOnce(Return(stability_report));
 
     // Expect the call to write the proto to a minidump. This involves
     // requesting a report from the crashpad database, writing the report, then
     // finalizing it with the database.
-    base::FilePath minidump_path = temp_dir_.path().AppendASCII("foo-1.dmp");
+    base::FilePath minidump_path = temp_dir_.GetPath().AppendASCII("foo-1.dmp");
     base::File minidump_file(
         minidump_path, base::File::FLAG_CREATE | base::File::File::FLAG_WRITE);
     crashpad_report_ = {minidump_file.GetPlatformFile(),
                         crashpad::UUID(UUID::InitializeWithNewTag{}),
                         minidump_path};
     EXPECT_CALL(database_, PrepareNewCrashReport(_))
         .Times(1)
         .WillOnce(DoAll(SetArgPointee<0>(&crashpad_report_),
                         Return(CrashReportDatabase::kNoError)));
 
@@ skipping 49 matching lines @@
 
 TEST(PostmortemReportCollectorTest, GetDebugStateFilePaths) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   // Create files.
   std::vector<base::FilePath> expected_paths;
   std::set<base::FilePath> excluded_paths;
   {
     // Matches the pattern.
-    base::FilePath path = temp_dir.path().AppendASCII("foo1.pma");
+    base::FilePath path = temp_dir.GetPath().AppendASCII("foo1.pma");
     base::ScopedFILE file(base::OpenFile(path, "w"));
     ASSERT_NE(file.get(), nullptr);
     expected_paths.push_back(path);
 
     // Matches the pattern, but is excluded.
-    path = temp_dir.path().AppendASCII("foo2.pma");
+    path = temp_dir.GetPath().AppendASCII("foo2.pma");
     file.reset(base::OpenFile(path, "w"));
     ASSERT_NE(file.get(), nullptr);
     ASSERT_TRUE(excluded_paths.insert(path).second);
 
     // Matches the pattern.
-    path = temp_dir.path().AppendASCII("foo3.pma");
+    path = temp_dir.GetPath().AppendASCII("foo3.pma");
     file.reset(base::OpenFile(path, "w"));
     ASSERT_NE(file.get(), nullptr);
     expected_paths.push_back(path);
 
     // Does not match the pattern.
-    path = temp_dir.path().AppendASCII("bar.baz");
+    path = temp_dir.GetPath().AppendASCII("bar.baz");
     file.reset(base::OpenFile(path, "w"));
     ASSERT_NE(file.get(), nullptr);
   }
 
   PostmortemReportCollector collector;
   EXPECT_THAT(
       collector.GetDebugStateFilePaths(
-          temp_dir.path(), FILE_PATH_LITERAL("foo*.pma"), excluded_paths),
+          temp_dir.GetPath(), FILE_PATH_LITERAL("foo*.pma"), excluded_paths),
       testing::UnorderedElementsAreArray(expected_paths));
 }
 
 TEST(PostmortemReportCollectorTest, CollectEmptyFile) {
   // Create an empty file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  base::FilePath file_path = temp_dir.path().AppendASCII("empty.pma");
+  base::FilePath file_path = temp_dir.GetPath().AppendASCII("empty.pma");
   {
     base::ScopedFILE file(base::OpenFile(file_path, "w"));
     ASSERT_NE(file.get(), nullptr);
   }
   ASSERT_TRUE(PathExists(file_path));
 
   // Validate collection: an empty file cannot suppport an analyzer.
   PostmortemReportCollector collector;
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::ANALYZER_CREATION_FAILED,
             collector.Collect(file_path, &report));
 }
 
 TEST(PostmortemReportCollectorTest, CollectRandomFile) {
   // Create a file with content we don't expect to be valid for a debug file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  base::FilePath file_path = temp_dir.path().AppendASCII("invalid_content.pma");
+  base::FilePath file_path =
+      temp_dir.GetPath().AppendASCII("invalid_content.pma");
   {
     base::ScopedFILE file(base::OpenFile(file_path, "w"));
     ASSERT_NE(file.get(), nullptr);
     // Assuming this size is greater than the minimum size of a debug file.
     std::vector<uint8_t> data(1024);
     for (size_t i = 0; i < data.size(); ++i)
       data[i] = i % UINT8_MAX;
     ASSERT_EQ(data.size(),
               fwrite(&data.at(0), sizeof(uint8_t), data.size(), file.get()));
   }
@@ skipping 18 matching lines @@
 }  // namespace
 
 class PostmortemReportCollectorCollectionTest : public testing::Test {
  public:
   // Create a proper debug file.
   void SetUp() override {
     testing::Test::SetUp();
 
     // Create a file backed allocator.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    debug_file_path_ = temp_dir_.path().AppendASCII("debug_file.pma");
+    debug_file_path_ = temp_dir_.GetPath().AppendASCII("debug_file.pma");
     std::unique_ptr<PersistentMemoryAllocator> allocator = CreateAllocator();
     ASSERT_NE(nullptr, allocator);
 
     size_t tracker_mem_size =
         ThreadActivityTracker::SizeForStackDepth(kStackDepth);
     ASSERT_GT(kFileSize, tracker_mem_size);
 
     // Create some debug data using trackers.
     std::unique_ptr<ThreadActivityTracker> tracker =
         CreateTracker(allocator.get(), tracker_mem_size);
@@ skipping 65 matching lines @@
   // Build the expected report.
   StabilityReport expected_report;
   ProcessState* process_state = expected_report.add_process_states();
   ThreadState* thread_state = process_state->add_threads();
   thread_state->set_thread_name(base::PlatformThread::GetName());
 
   ASSERT_EQ(expected_report.SerializeAsString(), report->SerializeAsString());
 }
 
 }  // namespace browser_watcher