Move PathExists to base namespace.

chrome/browser/chromeos/drive/file_cache_unittest.cc

 // Copyright (c) 2012 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/chromeos/drive/file_cache.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 149 matching lines @@
   void VerifyRemoveFromCache(FileError error,
                              const std::string& resource_id,
                              const std::string& md5) {
     EXPECT_EQ(expected_error_, error);
 
     FileCacheEntry cache_entry;
     if (!GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry)) {
       EXPECT_EQ(FILE_ERROR_OK, error);
 
       const base::FilePath path = cache_->GetCacheFilePath(resource_id);
-      EXPECT_FALSE(file_util::PathExists(path));
+      EXPECT_FALSE(base::PathExists(path));
     }
   }
 
   void TestPin(const std::string& resource_id,
                FileError expected_error,
                int expected_cache_state) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
 
     FileError error = FILE_ERROR_OK;
@@ skipping 79 matching lines @@
                                               &entry));
 
     FileError error = FILE_ERROR_OK;
     base::FilePath cache_file_path;
     cache_->MarkAsMountedOnUIThread(
         resource_id,
         google_apis::test_util::CreateCopyResultCallback(
             &error, &cache_file_path));
     test_util::RunBlockingPoolTask();
 
-    EXPECT_TRUE(file_util::PathExists(cache_file_path));
+    EXPECT_TRUE(base::PathExists(cache_file_path));
     EXPECT_EQ(cache_file_path, cache_->GetCacheFilePath(resource_id));
   }
 
   void TestMarkAsUnmounted(const std::string& resource_id,
                            const std::string& md5,
                            const base::FilePath& file_path,
                            FileError expected_error,
                            int expected_cache_state) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
 
     FileError error = FILE_ERROR_OK;
     cache_->MarkAsUnmountedOnUIThread(
         file_path,
         google_apis::test_util::CreateCopyResultCallback(&error));
     test_util::RunBlockingPoolTask();
 
     base::FilePath cache_file_path;
     cache_->GetFileOnUIThread(
         resource_id, md5,
         google_apis::test_util::CreateCopyResultCallback(
             &error, &cache_file_path));
     test_util::RunBlockingPoolTask();
     EXPECT_EQ(FILE_ERROR_OK, error);
 
-    EXPECT_TRUE(file_util::PathExists(cache_file_path));
+    EXPECT_TRUE(base::PathExists(cache_file_path));
     EXPECT_EQ(cache_file_path, cache_->GetCacheFilePath(resource_id));
   }
 
   void VerifyCacheFileState(FileError error,
                             const std::string& resource_id,
                             const std::string& md5) {
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     FileCacheEntry cache_entry;
     const bool cache_entry_found =
         GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
     if ((expected_cache_state_ & TEST_CACHE_STATE_PRESENT) ||
         (expected_cache_state_ & TEST_CACHE_STATE_PINNED)) {
       ASSERT_TRUE(cache_entry_found);
       EXPECT_EQ((expected_cache_state_ & TEST_CACHE_STATE_PINNED) != 0,
                 cache_entry.is_pinned());
       EXPECT_EQ((expected_cache_state_ & TEST_CACHE_STATE_PRESENT) != 0,
                 cache_entry.is_present());
       EXPECT_EQ((expected_cache_state_ & TEST_CACHE_STATE_DIRTY) != 0,
                 cache_entry.is_dirty());
     } else {
       EXPECT_FALSE(cache_entry_found);
     }
 
     // Verify actual cache file.
     base::FilePath dest_path = cache_->GetCacheFilePath(resource_id);
     EXPECT_EQ((expected_cache_state_ & TEST_CACHE_STATE_PRESENT) != 0,
-              file_util::PathExists(dest_path));
+              base::PathExists(dest_path));
   }
 
   // Helper function to call GetCacheEntry from origin thread.
   bool GetCacheEntryFromOriginThread(const std::string& resource_id,
                                      const std::string& md5,
                                      FileCacheEntry* cache_entry) {
     bool result = false;
     cache_->GetCacheEntryOnUIThread(
         resource_id, md5,
         google_apis::test_util::CreateCopyResultCallback(&result, cache_entry));
@@ skipping 257 matching lines @@
                 TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_DIRTY);
 
   // Verifies dirty file exists.
   base::FilePath dirty_path;
   FileError error = FILE_ERROR_FAILED;
   cache_->GetFileOnUIThread(
       resource_id, md5,
       google_apis::test_util::CreateCopyResultCallback(&error, &dirty_path));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
-  EXPECT_TRUE(file_util::PathExists(dirty_path));
+  EXPECT_TRUE(base::PathExists(dirty_path));
 
   // Pin the dirty file.
   TestPin(resource_id, FILE_ERROR_OK,
           TEST_CACHE_STATE_PRESENT |
           TEST_CACHE_STATE_DIRTY |
           TEST_CACHE_STATE_PINNED);
 
   // Verify dirty file still exist at the same pathname.
-  EXPECT_TRUE(file_util::PathExists(dirty_path));
+  EXPECT_TRUE(base::PathExists(dirty_path));
 
   // Unpin the dirty file.
   TestUnpin(resource_id, FILE_ERROR_OK,
             TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_DIRTY);
 
   // Verify dirty file still exist at the same pathname.
-  EXPECT_TRUE(file_util::PathExists(dirty_path));
+  EXPECT_TRUE(base::PathExists(dirty_path));
 }
 
 TEST_F(FileCacheTestOnUIThread, DirtyCacheRepetitive) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, dummy_file_path_,
                    FILE_ERROR_OK, TEST_CACHE_STATE_PRESENT);
 
@@ skipping 278 matching lines @@
 
   // Call FreeDiskSpaceIfNeededFor().
   fake_free_disk_space_getter_->set_default_value(test_util::kLotsOfSpace);
   fake_free_disk_space_getter_->PushFakeValue(0);
   const int64 kNeededBytes = 1;
   EXPECT_TRUE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
   // Only 'temporary' file gets removed.
   FileCacheEntry entry;
   EXPECT_FALSE(cache_->GetCacheEntry(resource_id_tmp, md5_tmp, &entry));
-  EXPECT_FALSE(file_util::PathExists(tmp_path));
+  EXPECT_FALSE(base::PathExists(tmp_path));
 
   EXPECT_TRUE(cache_->GetCacheEntry(resource_id_pinned, md5_pinned, &entry));
-  EXPECT_TRUE(file_util::PathExists(pinned_path));
+  EXPECT_TRUE(base::PathExists(pinned_path));
 
   // Returns false when disk space cannot be freed.
   fake_free_disk_space_getter_->set_default_value(0);
   EXPECT_FALSE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 }
 
 TEST_F(FileCacheTest, ImportOldDB) {
   const base::FilePath old_db_path = temp_dir_.path().AppendASCII("old_db.db");
 
   const std::string key1 = "key1";
   const std::string md5_1 = "md5_1";
   const std::string key2 = "key2";
   const std::string md5_2 = "md5_2";
 
   // Set up data to be imported.
   {
     FileCacheMetadata old_metadata(NULL);
     ASSERT_TRUE(old_metadata.Initialize(old_db_path));
 
     FileCacheEntry entry;
     entry.set_md5(md5_1);
     old_metadata.AddOrUpdateCacheEntry(key1, entry);
 
     entry.set_md5(md5_2);
     old_metadata.AddOrUpdateCacheEntry(key2, entry);
   }
-  EXPECT_TRUE(file_util::PathExists(old_db_path));
+  EXPECT_TRUE(base::PathExists(old_db_path));
 
   // Do import.
   EXPECT_TRUE(ImportOldDB(cache_.get(), old_db_path));
 
   // Old DB should be removed.
-  EXPECT_FALSE(file_util::PathExists(old_db_path));
+  EXPECT_FALSE(base::PathExists(old_db_path));
 
   // Data is imported correctly.
   FileCacheEntry entry;
   EXPECT_TRUE(cache_->GetCacheEntry(key1, std::string(), &entry));
   EXPECT_EQ(md5_1, entry.md5());
   EXPECT_TRUE(cache_->GetCacheEntry(key2, std::string(), &entry));
   EXPECT_EQ(md5_2, entry.md5());
 }
 
 TEST_F(FileCacheTest, RenameCacheFilesToNewFormat) {
@@ skipping 30 matching lines @@
                                           &contents));
   EXPECT_EQ("koo", contents);
   contents.clear();
   EXPECT_TRUE(file_util::ReadFileToString(file_directory.AppendASCII("id_kyu"),
                                           &contents));
   EXPECT_EQ("kyu", contents);
 }
 
 }  // namespace internal
 }  // namespace drive