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

content/browser/appcache/appcache_disk_cache_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 "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 40 matching lines @@
   static const int k10MBytes = 10 * 1024 * 1024;
 };
 
 TEST_F(AppCacheDiskCacheTest, DisablePriorToInitCompletion) {
   AppCacheDiskCache::Entry* entry = NULL;
 
   // Create an instance and start it initializing, queue up
   // one of each kind of "entry" function.
   std::unique_ptr<AppCacheDiskCache> disk_cache(new AppCacheDiskCache);
   EXPECT_FALSE(disk_cache->is_disabled());
-  disk_cache->InitWithDiskBackend(
-      directory_.path(), k10MBytes, false, cache_thread_, completion_callback_);
+  disk_cache->InitWithDiskBackend(directory_.GetPath(), k10MBytes, false,
+                                  cache_thread_, completion_callback_);
   disk_cache->CreateEntry(1, &entry, completion_callback_);
   disk_cache->OpenEntry(2, &entry, completion_callback_);
   disk_cache->DoomEntry(3, completion_callback_);
 
   // Pull the plug on all that.
   EXPECT_FALSE(disk_cache->is_disabled());
   disk_cache->Disable();
   EXPECT_TRUE(disk_cache->is_disabled());
 
   FlushCacheTasks();
 
   EXPECT_EQ(NULL, entry);
   EXPECT_EQ(4u, completion_results_.size());
   for (std::vector<int>::const_iterator iter = completion_results_.begin();
        iter < completion_results_.end(); ++iter) {
     EXPECT_EQ(net::ERR_ABORTED, *iter);
   }
 
   // Ensure the directory can be deleted at this point.
-  EXPECT_TRUE(base::DirectoryExists(directory_.path()));
-  EXPECT_FALSE(base::IsDirectoryEmpty(directory_.path()));
-  EXPECT_TRUE(base::DeleteFile(directory_.path(), true));
-  EXPECT_FALSE(base::DirectoryExists(directory_.path()));
+  EXPECT_TRUE(base::DirectoryExists(directory_.GetPath()));
+  EXPECT_FALSE(base::IsDirectoryEmpty(directory_.GetPath()));
+  EXPECT_TRUE(base::DeleteFile(directory_.GetPath(), true));
+  EXPECT_FALSE(base::DirectoryExists(directory_.GetPath()));
 }
 
 TEST_F(AppCacheDiskCacheTest, DisableAfterInitted) {
   // Create an instance and let it fully init.
   std::unique_ptr<AppCacheDiskCache> disk_cache(new AppCacheDiskCache);
   EXPECT_FALSE(disk_cache->is_disabled());
-  disk_cache->InitWithDiskBackend(
-      directory_.path(), k10MBytes, false, cache_thread_, completion_callback_);
+  disk_cache->InitWithDiskBackend(directory_.GetPath(), k10MBytes, false,
+                                  cache_thread_, completion_callback_);
   FlushCacheTasks();
   EXPECT_EQ(1u, completion_results_.size());
   EXPECT_EQ(net::OK, completion_results_[0]);
 
   // Pull the plug
   disk_cache->Disable();
   FlushCacheTasks();
 
   // Ensure the directory can be deleted at this point.
-  EXPECT_TRUE(base::DirectoryExists(directory_.path()));
-  EXPECT_FALSE(base::IsDirectoryEmpty(directory_.path()));
-  EXPECT_TRUE(base::DeleteFile(directory_.path(), true));
-  EXPECT_FALSE(base::DirectoryExists(directory_.path()));
+  EXPECT_TRUE(base::DirectoryExists(directory_.GetPath()));
+  EXPECT_FALSE(base::IsDirectoryEmpty(directory_.GetPath()));
+  EXPECT_TRUE(base::DeleteFile(directory_.GetPath(), true));
+  EXPECT_FALSE(base::DirectoryExists(directory_.GetPath()));
 
   // Methods should return immediately when disabled and not invoke
   // the callback at all.
   AppCacheDiskCache::Entry* entry = NULL;
   completion_results_.clear();
   EXPECT_EQ(net::ERR_ABORTED,
             disk_cache->CreateEntry(1, &entry, completion_callback_));
   EXPECT_EQ(net::ERR_ABORTED,
             disk_cache->OpenEntry(2, &entry, completion_callback_));
   EXPECT_EQ(net::ERR_ABORTED,
             disk_cache->DoomEntry(3, completion_callback_));
   FlushCacheTasks();
   EXPECT_TRUE(completion_results_.empty());
 }
 
 // Flaky on Android: http://crbug.com/339534
 TEST_F(AppCacheDiskCacheTest, DISABLED_DisableWithEntriesOpen) {
   // Create an instance and let it fully init.
   std::unique_ptr<AppCacheDiskCache> disk_cache(new AppCacheDiskCache);
   EXPECT_FALSE(disk_cache->is_disabled());
-  disk_cache->InitWithDiskBackend(
-      directory_.path(), k10MBytes, false, cache_thread_, completion_callback_);
+  disk_cache->InitWithDiskBackend(directory_.GetPath(), k10MBytes, false,
+                                  cache_thread_, completion_callback_);
   FlushCacheTasks();
   EXPECT_EQ(1u, completion_results_.size());
   EXPECT_EQ(net::OK, completion_results_[0]);
 
   // Note: We don't have detailed expectations of the DiskCache
   // operations because on android it's really SimpleCache which
   // does behave differently.
   //
   // What matters for the corruption handling and service reinitiazation
   // is that the directory can be deleted after the calling Disable() method,
@@ skipping 18 matching lines @@
   // Queue up a read and a write.
   scoped_refptr<net::IOBuffer> read_buf = new net::IOBuffer(kDataLen);
   entry1->Read(0, 0, read_buf.get(), kDataLen, completion_callback_);
   entry2->Write(0, 0, write_buf.get(), kDataLen, completion_callback_);
 
   // Pull the plug
   disk_cache->Disable();
   FlushCacheTasks();
 
   // Ensure the directory can be deleted at this point.
-  EXPECT_TRUE(base::DirectoryExists(directory_.path()));
-  EXPECT_FALSE(base::IsDirectoryEmpty(directory_.path()));
-  EXPECT_TRUE(base::DeleteFile(directory_.path(), true));
-  EXPECT_FALSE(base::DirectoryExists(directory_.path()));
+  EXPECT_TRUE(base::DirectoryExists(directory_.GetPath()));
+  EXPECT_FALSE(base::IsDirectoryEmpty(directory_.GetPath()));
+  EXPECT_TRUE(base::DeleteFile(directory_.GetPath(), true));
+  EXPECT_FALSE(base::DirectoryExists(directory_.GetPath()));
 
   disk_cache.reset(NULL);
 
   // Also, new IO operations should fail immediately.
   EXPECT_EQ(
       net::ERR_ABORTED,
       entry1->Read(0, 0, read_buf.get(), kDataLen, completion_callback_));
   entry1->Close();
   entry2->Close();
 
   FlushCacheTasks();
 }
 
 }  // namespace content