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

content/browser/fileapi/obfuscated_file_util_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 <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <set>
@@ skipping 147 matching lines @@
         quota_status_(storage::kQuotaStatusUnknown),
         usage_(-1),
         weak_factory_(this) {}
 
   void SetUp() override {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
     storage_policy_ = new MockSpecialStoragePolicy();
 
     quota_manager_ = new storage::QuotaManager(
-        false /* is_incognito */, data_dir_.path(),
+        false /* is_incognito */, data_dir_.GetPath(),
         base::ThreadTaskRunnerHandle::Get().get(),
         base::ThreadTaskRunnerHandle::Get().get(), storage_policy_.get());
 
     // Every time we create a new sandbox_file_system helper,
     // it creates another context, which creates another path manager,
     // another sandbox_backend, and another OFU.
     // We need to pass in the context to skip all that.
     file_system_context_ = CreateFileSystemContextForTesting(
-        quota_manager_->proxy(),
-        data_dir_.path());
+        quota_manager_->proxy(), data_dir_.GetPath());
 
     sandbox_file_system_.SetUp(file_system_context_.get());
 
     change_observers_ =
         storage::MockFileChangeObserver::CreateList(&change_observer_);
   }
 
   void TearDown() override {
     quota_manager_ = NULL;
     sandbox_file_system_.TearDown();
@@ skipping 51 matching lines @@
     return std::unique_ptr<ObfuscatedFileUtil>(
         ObfuscatedFileUtil::CreateForTesting(
             storage_policy, data_dir_path(), NULL,
             base::ThreadTaskRunnerHandle::Get().get()));
   }
 
   ObfuscatedFileUtil* ofu() {
     return static_cast<ObfuscatedFileUtil*>(sandbox_file_system_.file_util());
   }
 
-  const base::FilePath& test_directory() const {
-    return data_dir_.path();
-  }
+  const base::FilePath& test_directory() const { return data_dir_.GetPath(); }
 
   const GURL& origin() const {
     return origin_;
   }
 
   storage::FileSystemType type() const { return type_; }
 
   std::string type_string() const {
     return GetTypeString(type_);
   }
@@ skipping 281 matching lines @@
     EXPECT_EQ(base::File::FILE_OK,
               ofu()->GetFileInfo(context.get(), url, &file_info, &local_path));
     EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT());
     if (is_file)  // Directories in OFU don't support atime.
       EXPECT_EQ(file_info.last_accessed.ToTimeT(), last_access_time.ToTimeT());
   }
 
   void TestCopyInForeignFileHelper(bool overwrite) {
     base::ScopedTempDir source_dir;
     ASSERT_TRUE(source_dir.CreateUniqueTempDir());
-    base::FilePath root_file_path = source_dir.path();
+    base::FilePath root_file_path = source_dir.GetPath();
     base::FilePath src_file_path = root_file_path.AppendASCII("file_name");
     FileSystemURL dest_url = CreateURLFromUTF8("new file");
     int64_t src_file_length = 87;
 
     base::File file(src_file_path,
                     base::File::FLAG_CREATE | base::File::FLAG_WRITE);
     ASSERT_TRUE(file.IsValid());
     EXPECT_TRUE(file.created());
     ASSERT_TRUE(file.SetLength(src_file_length));
     file.Close();
@@ skipping 228 matching lines @@
 
   int64_t ComputeCurrentUsage() {
     return sandbox_file_system_.ComputeCurrentOriginUsage() -
         sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   FileSystemContext* file_system_context() {
     return sandbox_file_system_.file_system_context();
   }
 
-  const base::FilePath& data_dir_path() const {
-    return data_dir_.path();
-  }
+  const base::FilePath& data_dir_path() const { return data_dir_.GetPath(); }
 
  protected:
   base::ScopedTempDir data_dir_;
   base::MessageLoopForIO message_loop_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
   scoped_refptr<storage::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
   storage::FileSystemType type_;
   SandboxFileSystemTestHelper sandbox_file_system_;
@@ skipping 1756 matching lines @@
   ofu()->GetDirectoryForOriginAndType(
       origin2, GetTypeString(kFileSystemTypeTemporary), false, &error);
   ASSERT_EQ(base::File::FILE_OK, error);
   error = base::File::FILE_ERROR_FAILED;
   ofu()->GetDirectoryForOriginAndType(
       origin2, GetTypeString(kFileSystemTypePersistent), false, &error);
   ASSERT_EQ(base::File::FILE_OK, error);
 }
 
 }  // namespace content