//base: Make ScopedTempDir::path() a GetPath() with a DCHECK

base/files/file_locking_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 "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/test/multiprocess_test.h"
@@ skipping 111 matching lines @@
  public:
   FileLockingTest() {}
 
  protected:
   void SetUp() override {
     testing::Test::SetUp();
 
     // Setup the temp dir and the lock file.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     lock_file_.Initialize(
-        temp_dir_.path().AppendASCII(kLockFile),
+        temp_dir_.GetPath().AppendASCII(kLockFile),
         File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE);
     ASSERT_TRUE(lock_file_.IsValid());
   }
 
   bool SignalEvent(const char* signal_file) {
-    return ::SignalEvent(temp_dir_.path(), signal_file);
+    return ::SignalEvent(temp_dir_.GetPath(), signal_file);
   }
 
   bool WaitForEventOrTimeout(const char* signal_file) {
-    return ::WaitForEventWithTimeout(temp_dir_.path(), signal_file,
+    return ::WaitForEventWithTimeout(temp_dir_.GetPath(), signal_file,
                                      TestTimeouts::action_timeout());
   }
 
   // Start a child process set to use the specified unlock action, and wait for
   // it to lock the file.
   void StartChildAndSignalLock(const char* unlock_action) {
     // Create a temporary dir and spin up a ChildLockExit subprocess against it.
-    const FilePath temp_path = temp_dir_.path();
+    const FilePath temp_path = temp_dir_.GetPath();
     base::CommandLine child_command_line(
         base::GetMultiProcessTestChildBaseCommandLine());
     child_command_line.AppendSwitchPath(kTempDirFlag, temp_path);
     child_command_line.AppendSwitch(unlock_action);
     lock_child_ =
         base::SpawnMultiProcessTestChild(ChildMainString, child_command_line,
                                          base::LaunchOptions());
     ASSERT_TRUE(lock_child_.IsValid());
 
     // Wait for the child to lock the file.
@@ skipping 56 matching lines @@
 // Test that killing the process releases the lock.  This should cover crashing.
 TEST_F(FileLockingTest, UnlockOnTerminate) {
   // The child will wait for an exit which never arrives.
   StartChildAndSignalLock(kExitUnlock);
 
   ASSERT_NE(File::FILE_OK, lock_file_.Lock());
   ASSERT_TRUE(lock_child_.Terminate(0, true));
   ASSERT_EQ(File::FILE_OK, lock_file_.Lock());
   ASSERT_EQ(File::FILE_OK, lock_file_.Unlock());
 }