c/browser, c/common, components M-N: Change ScopedTempDir::path() to GetPath()

chrome/browser/media_galleries/fileapi/picasa_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 "chrome/browser/media_galleries/fileapi/picasa_file_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 58 matching lines @@
         uid_(uid),
         image_files_(image_files),
         non_image_files_(non_image_files),
         folder_info_("", base::Time(), "", base::FilePath()) {
   }
 
   bool Init() {
     if (!folder_dir_.CreateUniqueTempDir())
       return false;
 
-    folder_info_ = AlbumInfo(name_, timestamp_, uid_, folder_dir_.path());
+    folder_info_ = AlbumInfo(name_, timestamp_, uid_, folder_dir_.GetPath());
 
     for (unsigned int i = 0; i < image_files_; ++i) {
       std::string image_filename = base::StringPrintf("img%05d.jpg", i);
       image_filenames_.insert(image_filename);
 
-      base::FilePath path = folder_dir_.path().AppendASCII(image_filename);
+      base::FilePath path = folder_dir_.GetPath().AppendASCII(image_filename);
 
       if (!WriteJPEGHeader(path))
         return false;
     }
 
     for (unsigned int i = 0; i < non_image_files_; ++i) {
-      base::FilePath path = folder_dir_.path().AppendASCII(
+      base::FilePath path = folder_dir_.GetPath().AppendASCII(
           base::StringPrintf("hello%05d.txt", i));
       if (base::WriteFile(path, NULL, 0) == -1)
         return false;
     }
 
     return true;
   }
 
   double GetVariantTimestamp() const {
-    DCHECK(!folder_dir_.path().empty());
+    DCHECK(!folder_dir_.GetPath().empty());
     base::Time variant_epoch;
     EXPECT_TRUE(base::Time::FromLocalExploded(picasa::kPmpVariantTimeEpoch,
                                               &variant_epoch));
 
     int64_t microseconds_since_epoch =
         (folder_info_.timestamp - variant_epoch).InMicroseconds();
 
     return static_cast<double>(microseconds_since_epoch) /
                                base::Time::kMicrosecondsPerDay;
   }
 
   const std::set<std::string>& image_filenames() const {
-    DCHECK(!folder_dir_.path().empty());
+    DCHECK(!folder_dir_.GetPath().empty());
     return image_filenames_;
   }
 
   const AlbumInfo& folder_info() const {
-    DCHECK(!folder_dir_.path().empty());
+    DCHECK(!folder_dir_.GetPath().empty());
     return folder_info_;
   }
 
   const base::Time& timestamp() const {
     return timestamp_;
   }
 
  private:
   const std::string name_;
   const base::Time timestamp_;
@@ skipping 108 matching lines @@
     scoped_refptr<storage::SpecialStoragePolicy> storage_policy =
         new content::MockSpecialStoragePolicy();
 
     SynchronouslyRunOnMediaTaskRunner(base::Bind(
         &PicasaFileUtilTest::SetUpOnMediaTaskRunner, base::Unretained(this)));
 
     media_path_filter_.reset(new MediaPathFilter());
 
     ScopedVector<storage::FileSystemBackend> additional_providers;
     additional_providers.push_back(new TestMediaFileSystemBackend(
-        profile_dir_.path(),
+        profile_dir_.GetPath(),
         new TestPicasaFileUtil(media_path_filter_.get(),
                                picasa_data_provider_.get())));
 
     file_system_context_ = new storage::FileSystemContext(
         base::ThreadTaskRunnerHandle::Get().get(),
         base::ThreadTaskRunnerHandle::Get().get(),
         storage::ExternalMountPoints::CreateRefCounted().get(),
         storage_policy.get(), NULL, std::move(additional_providers),
-        std::vector<storage::URLRequestAutoMountHandler>(), profile_dir_.path(),
-        content::CreateAllowFileAccessOptions());
+        std::vector<storage::URLRequestAutoMountHandler>(),
+        profile_dir_.GetPath(), content::CreateAllowFileAccessOptions());
   }
 
   void TearDown() override {
     SynchronouslyRunOnMediaTaskRunner(
         base::Bind(&PicasaFileUtilTest::TearDownOnMediaTaskRunner,
                    base::Unretained(this)));
   }
 
  protected:
   void SetUpOnMediaTaskRunner() {
@@ skipping 283 matching lines @@
   std::vector<AlbumInfo> albums;
   AlbumInfo info;
   info.name = "albumname";
   info.uid = "albumuid";
   info.timestamp = test_date;
   albums.push_back(info);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  base::FilePath image_path = temp_dir.path().AppendASCII("img.jpg");
+  base::FilePath image_path = temp_dir.GetPath().AppendASCII("img.jpg");
   ASSERT_TRUE(WriteJPEGHeader(image_path));
 
   AlbumImagesMap albums_images;
   albums_images[info.uid] = AlbumImages();
   albums_images[info.uid]["mapped_name.jpg"] = image_path;
 
   SetupFolders(&test_folders, albums, albums_images);
 
   FileSystemOperation::FileEntryList contents;
   FileSystemURL url =
@@ skipping 19 matching lines @@
   operation_runner()->CreateSnapshotFile(
       CreateURL(std::string(kPicasaDirAlbums) +
                 "/albumname 2013-04-16/mapped_name.jpg"),
       snapshot_callback);
   loop.Run();
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(image_path, platform_path_result);
 }
 
 }  // namespace picasa