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

content/browser/appcache/appcache_database_unittest.cc

 // Copyright 2014 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 <stdint.h>
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 40 matching lines @@
 
   std::set<GURL> origins;
   EXPECT_TRUE(db.FindOriginsWithGroups(&origins));
   EXPECT_TRUE(origins.empty());
 }
 
 TEST(AppCacheDatabaseTest, ReCreate) {
   // Real files on disk for this test.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  const base::FilePath kDbFile = temp_dir.path().AppendASCII("appcache.db");
-  const base::FilePath kNestedDir = temp_dir.path().AppendASCII("nested");
+  const base::FilePath kDbFile = temp_dir.GetPath().AppendASCII("appcache.db");
+  const base::FilePath kNestedDir = temp_dir.GetPath().AppendASCII("nested");
   const base::FilePath kOtherFile =  kNestedDir.AppendASCII("other_file");
   EXPECT_TRUE(base::CreateDirectory(kNestedDir));
   EXPECT_EQ(3, base::WriteFile(kOtherFile, "foo", 3));
 
   AppCacheDatabase db(kDbFile);
   EXPECT_FALSE(db.LazyOpen(false));
   EXPECT_TRUE(db.LazyOpen(true));
 
   EXPECT_TRUE(base::PathExists(kDbFile));
   EXPECT_TRUE(base::DirectoryExists(kNestedDir));
@@ skipping 10 matching lines @@
 // Only run in release builds because sql::Connection and familiy
 // crank up DLOG(FATAL)'ness and this test presents it with
 // intentionally bad data which causes debug builds to exit instead
 // of run to completion. In release builds, errors the are delivered
 // to the consumer so  we can test the error handling of the consumer.
 // TODO: crbug/328576
 TEST(AppCacheDatabaseTest, QuickIntegrityCheck) {
   // Real files on disk for this test too, a corrupt database file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  base::FilePath mock_dir = temp_dir.path().AppendASCII("mock");
+  base::FilePath mock_dir = temp_dir.GetPath().AppendASCII("mock");
   ASSERT_TRUE(base::CreateDirectory(mock_dir));
 
   const base::FilePath kDbFile = mock_dir.AppendASCII("appcache.db");
   const base::FilePath kOtherFile = mock_dir.AppendASCII("other_file");
   EXPECT_EQ(3, base::WriteFile(kOtherFile, "foo", 3));
 
   // First create a valid db file.
   {
     AppCacheDatabase db(kDbFile);
     EXPECT_TRUE(db.LazyOpen(true));
@@ skipping 14 matching lines @@
     EXPECT_TRUE(base::PathExists(kDbFile));
     EXPECT_TRUE(expecter.SawExpectedErrors());
   }
 }
 #endif  // NDEBUG
 
 TEST(AppCacheDatabaseTest, WasCorrutionDetected) {
   // Real files on disk for this test too, a corrupt database file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  const base::FilePath kDbFile = temp_dir.path().AppendASCII("appcache.db");
+  const base::FilePath kDbFile = temp_dir.GetPath().AppendASCII("appcache.db");
 
   // First create a valid db file.
   AppCacheDatabase db(kDbFile);
   EXPECT_TRUE(db.LazyOpen(true));
   EXPECT_TRUE(base::PathExists(kDbFile));
   EXPECT_FALSE(db.was_corruption_detected());
 
   // Break it.
   ASSERT_TRUE(sql::test::CorruptSizeInHeader(kDbFile));
 
   // See the the corruption is detected and reported.
   {
     sql::test::ScopedErrorExpecter expecter;
     expecter.ExpectError(SQLITE_CORRUPT);
     std::map<GURL, int64_t> usage_map;
     EXPECT_FALSE(db.GetAllOriginUsage(&usage_map));
     EXPECT_TRUE(db.was_corruption_detected());
     EXPECT_TRUE(base::PathExists(kDbFile));
     EXPECT_TRUE(expecter.SawExpectedErrors());
   }
 }
 
 TEST(AppCacheDatabaseTest, ExperimentalFlags) {
   const char kExperimentFlagsKey[] = "ExperimentFlags";
   std::string kInjectedFlags("exp1,exp2");
 
   // Real files on disk for this test.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  const base::FilePath kDbFile = temp_dir.path().AppendASCII("appcache.db");
-  const base::FilePath kOtherFile =  temp_dir.path().AppendASCII("other_file");
+  const base::FilePath kDbFile = temp_dir.GetPath().AppendASCII("appcache.db");
+  const base::FilePath kOtherFile =
+      temp_dir.GetPath().AppendASCII("other_file");
   EXPECT_EQ(3, base::WriteFile(kOtherFile, "foo", 3));
   EXPECT_TRUE(base::PathExists(kOtherFile));
 
   // Inject a non empty flags value, and verify it got there.
   {
     AppCacheDatabase db(kDbFile);
     EXPECT_TRUE(db.LazyOpen(true));
     EXPECT_TRUE(db.meta_table_->SetValue(kExperimentFlagsKey, kInjectedFlags));
     std::string flags;
     EXPECT_TRUE(db.meta_table_->GetValue(kExperimentFlagsKey, &flags));
@@ skipping 655 matching lines @@
   EXPECT_EQ(5000, usage_map[kOtherOrigin]);
 }
 
 #if defined(APPCACHE_USE_SIMPLE_CACHE)
 // There is no such upgrade path in this case.
 #else
 TEST(AppCacheDatabaseTest, UpgradeSchema4to7) {
   // Real file on disk for this test.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  const base::FilePath kDbFile = temp_dir.path().AppendASCII("upgrade4.db");
+  const base::FilePath kDbFile = temp_dir.GetPath().AppendASCII("upgrade4.db");
 
   const GURL kMockOrigin("http://mockorigin/");
   const char kNamespaceUrlFormat[] = "namespace%d";
   const char kWhitelistUrlFormat[] = "whitelist%d";
   const char kTargetUrlFormat[] = "target%d";
   const int kNumNamespaces = 10;
   const int kWhitelistCacheId = 1;
 
   // Create a v4 schema based database containing some fallback records.
   {
@@ skipping 224 matching lines @@
   }
 }
 #endif  // !APPCACHE_USE_SIMPLE_CACHE
 
 // Verify last_full_update_check_time and first_evictable_error_time.
 TEST(AppCacheDatabaseTest, UpgradeSchema5or6to7) {
   // Real file on disk for this test.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   const base::FilePath kDbFile =
-      temp_dir.path().AppendASCII("upgrade5or6to7.db");
+      temp_dir.GetPath().AppendASCII("upgrade5or6to7.db");
 
   const GURL kMockOrigin("http://mockorigin/");
   const base::Time kMockTime = base::Time::Now();
 
   // Create a v5or6 schema based database containing two groups, one
   // that has an associated cache as expected, and one which erroneously
   // is missing its cache record.
   {
     // The SQL schema is the same in these two cases.
 #if defined(APPCACHE_USE_SIMPLE_CACHE)
@@ skipping 205 matching lines @@
   AppCacheDatabase::GroupRecord group;
   EXPECT_TRUE(db.FindGroup(1, &group));
   EXPECT_EQ(kMockTime, group.last_full_update_check_time);
   EXPECT_EQ(kZeroTime, group.first_evictable_error_time);
   EXPECT_TRUE(db.FindGroup(2, &group));
   EXPECT_EQ(kZeroTime, group.last_full_update_check_time);
   EXPECT_EQ(kZeroTime, group.first_evictable_error_time);
 }
 
 }  // namespace content