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

content/browser/appcache/appcache_storage_impl_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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <stack>
@@ skipping 1657 matching lines @@
   void Reinitialize3() {
     // Recover from a corrupt sql database discovered while
     // installing a new appcache.
     Reinitialize(CORRUPT_SQL_ON_INSTALL);
   }
 
   void Reinitialize(ReinitTestCase test_case) {
     // Unlike all of the other tests, this one actually read/write files.
     ASSERT_TRUE(temp_directory_.CreateUniqueTempDir());
 
-    AppCacheDatabase db(temp_directory_.path().AppendASCII("Index"));
+    AppCacheDatabase db(temp_directory_.GetPath().AppendASCII("Index"));
     EXPECT_TRUE(db.LazyOpen(true));
 
     if (test_case == CORRUPT_CACHE_ON_INSTALL ||
         test_case == CORRUPT_CACHE_ON_LOAD_EXISTING) {
       // Create a corrupt/unopenable disk_cache index file.
       const std::string kCorruptData("deadbeef");
       base::FilePath disk_cache_directory =
-          temp_directory_.path().AppendASCII("Cache");
+          temp_directory_.GetPath().AppendASCII("Cache");
       ASSERT_TRUE(base::CreateDirectory(disk_cache_directory));
       base::FilePath index_file = disk_cache_directory.AppendASCII("index");
       EXPECT_EQ(static_cast<int>(kCorruptData.length()),
                 base::WriteFile(
                     index_file, kCorruptData.data(), kCorruptData.length()));
     }
 
     // Create records for a degenerate cached manifest that only contains
     // one entry for the manifest file resource.
     if (test_case == CORRUPT_CACHE_ON_LOAD_EXISTING) {
-      AppCacheDatabase db(temp_directory_.path().AppendASCII("Index"));
+      AppCacheDatabase db(temp_directory_.GetPath().AppendASCII("Index"));
       GURL manifest_url = MockHttpServer::GetMockUrl("manifest");
 
       AppCacheDatabase::GroupRecord group_record;
       group_record.group_id = 1;
       group_record.manifest_url = manifest_url;
       group_record.origin = manifest_url.GetOrigin();
       EXPECT_TRUE(db.InsertGroup(&group_record));
       AppCacheDatabase::CacheRecord cache_record;
       cache_record.cache_id = 1;
       cache_record.group_id = 1;
       cache_record.online_wildcard = false;
       cache_record.update_time = kZeroTime;
       cache_record.cache_size = kDefaultEntrySize;
       EXPECT_TRUE(db.InsertCache(&cache_record));
       AppCacheDatabase::EntryRecord entry_record;
       entry_record.cache_id = 1;
       entry_record.url = manifest_url;
       entry_record.flags = AppCacheEntry::MANIFEST;
       entry_record.response_id = 1;
       entry_record.response_size = kDefaultEntrySize;
       EXPECT_TRUE(db.InsertEntry(&entry_record));
     }
 
     // Recreate the service to point at the db and corruption on disk.
     service_.reset(new AppCacheServiceImpl(NULL));
     service_->set_request_context(io_thread->request_context());
-    service_->Initialize(temp_directory_.path(),
-                         db_thread->task_runner(),
+    service_->Initialize(temp_directory_.GetPath(), db_thread->task_runner(),
                          db_thread->task_runner());
     mock_quota_manager_proxy_ = new MockQuotaManagerProxy();
     service_->quota_manager_proxy_ = mock_quota_manager_proxy_;
     delegate_.reset(new MockStorageDelegate(this));
 
     // Additional setup to observe reinitailize happens.
     observer_.reset(new MockServiceObserver(this));
     service_->AddObserver(observer_.get());
 
     // We continue after the init task is complete including the callback
     // on the current thread.
     FlushDbThreadTasks();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&AppCacheStorageImplTest::Continue_Reinitialize,
                               base::Unretained(this), test_case));
   }
 
   void Continue_Reinitialize(ReinitTestCase test_case) {
     const int kMockProcessId = 1;
     backend_.reset(new AppCacheBackendImpl);
     backend_->Initialize(service_.get(), &frontend_, kMockProcessId);
 
     if (test_case == CORRUPT_SQL_ON_INSTALL) {
       // Break the db file
       EXPECT_FALSE(database()->was_corruption_detected());
       ASSERT_TRUE(sql::test::CorruptSizeInHeader(
-          temp_directory_.path().AppendASCII("Index")));
+          temp_directory_.GetPath().AppendASCII("Index")));
     }
 
     if (test_case == CORRUPT_CACHE_ON_INSTALL  ||
         test_case == CORRUPT_SQL_ON_INSTALL) {
       // Try to create a new appcache, the resulting update job will
       // eventually fail when it gets to disk cache initialization.
       backend_->RegisterHost(1);
       AppCacheHost* host1 = backend_->GetHost(1);
       const GURL kEmptyPageUrl(MockHttpServer::GetMockUrl("empty.html"));
       host1->first_party_url_ = kEmptyPageUrl;
@@ skipping 23 matching lines @@
         base::Unretained(this),
         test_case));
   }
 
   void Verify_Reinitialized(ReinitTestCase test_case) {
     // Verify we got notified of reinit and a new storage instance is created,
     // and that the old data has been deleted.
     EXPECT_TRUE(observer_->observed_old_storage_.get());
     EXPECT_TRUE(observer_->observed_old_storage_->storage() != storage());
     EXPECT_FALSE(PathExists(
-        temp_directory_.path().AppendASCII("Cache").AppendASCII("index")));
-    EXPECT_FALSE(PathExists(
-        temp_directory_.path().AppendASCII("Index")));
+        temp_directory_.GetPath().AppendASCII("Cache").AppendASCII("index")));
+    EXPECT_FALSE(PathExists(temp_directory_.GetPath().AppendASCII("Index")));
 
     if (test_case == CORRUPT_SQL_ON_INSTALL) {
       AppCacheStorageImpl* storage = static_cast<AppCacheStorageImpl*>(
           observer_->observed_old_storage_->storage());
       EXPECT_TRUE(storage->database_->was_corruption_detected());
     }
 
     // Verify that the hosts saw appropriate events.
     if (test_case == CORRUPT_CACHE_ON_INSTALL ||
         test_case == CORRUPT_SQL_ON_INSTALL) {
@@ skipping 220 matching lines @@
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize2);
 }
 
 TEST_F(AppCacheStorageImplTest, Reinitialize3) {
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize3);
 }
 
 // That's all folks!
 
 }  // namespace content