Move PathExists to base namespace.

webkit/browser/database/database_tracker_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 "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 231 matching lines @@
     net::TestCompletionCallback callback;
     int result = tracker->DeleteDatabase(kOrigin1, kDB1, callback.callback());
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     ASSERT_FALSE(callback.have_result());
     EXPECT_TRUE(observer.DidReceiveNewNotification());
     EXPECT_EQ(kOrigin1, observer.GetNotificationOriginIdentifier());
     EXPECT_EQ(kDB1, observer.GetNotificationDatabaseName());
     tracker->DatabaseClosed(kOrigin1, kDB1);
     result = callback.GetResult(result);
     EXPECT_EQ(net::OK, result);
-    EXPECT_FALSE(file_util::PathExists(
+    EXPECT_FALSE(base::PathExists(
           tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
 
     // Recreate db1.
     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                             &database_size);
     EXPECT_TRUE(file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
         base::FilePath::FromWStringHack(UTF16ToWide(
             tracker->GetOriginDirectory(kOrigin1))))));
     EXPECT_EQ(1, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
@@ skipping 15 matching lines @@
     yesterday -= base::TimeDelta::FromDays(1);
     result = tracker->DeleteDataModifiedSince(
         yesterday, callback.callback());
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     ASSERT_FALSE(callback.have_result());
     EXPECT_TRUE(observer.DidReceiveNewNotification());
     tracker->DatabaseClosed(kOrigin1, kDB1);
     tracker->DatabaseClosed(kOrigin2, kDB2);
     result = callback.GetResult(result);
     EXPECT_EQ(net::OK, result);
-    EXPECT_FALSE(file_util::PathExists(
+    EXPECT_FALSE(base::PathExists(
         tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
     EXPECT_TRUE(
-        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
+        base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
     EXPECT_TRUE(
-        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
+        base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
 
     tracker->DatabaseClosed(kOrigin2, kDB3);
     tracker->RemoveObserver(&observer);
   }
 
   static void TestDatabaseTracker(bool incognito_mode) {
     // Initialize the tracker database.
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
@@ skipping 302 matching lines @@
         new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
 
     // Get all data for all origins.
     std::vector<OriginInfo> origins_info;
     EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
     // kOrigin1 was not session-only, so it survived. kOrigin2 was session-only
     // and it got deleted.
     EXPECT_EQ(size_t(1), origins_info.size());
     EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
     EXPECT_TRUE(
-        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
+        base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
     EXPECT_EQ(base::FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2));
 
     // The origin directory of kOrigin1 remains, but the origin directory of
     // kOrigin2 is deleted.
-    EXPECT_TRUE(file_util::PathExists(origin1_db_dir));
-    EXPECT_FALSE(file_util::PathExists(origin2_db_dir));
+    EXPECT_TRUE(base::PathExists(origin1_db_dir));
+    EXPECT_FALSE(base::PathExists(origin2_db_dir));
   }
 
   static void DatabaseTrackerSetForceKeepSessionState() {
     int64 database_size = 0;
     const std::string kOrigin1 =
         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
     const base::string16 kDB1 = ASCIIToUTF16("db1");
     const base::string16 kDB2 = ASCIIToUTF16("db2");
@@ skipping 52 matching lines @@
     // At this point, the database tracker should be gone. Create a new one.
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
 
     // Get all data for all origins.
     std::vector<OriginInfo> origins_info;
     EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
     // No origins were deleted.
     EXPECT_EQ(size_t(2), origins_info.size());
     EXPECT_TRUE(
-        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
+        base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
     EXPECT_TRUE(
-        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
+        base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
 
-    EXPECT_TRUE(file_util::PathExists(origin1_db_dir));
-    EXPECT_TRUE(file_util::PathExists(origin2_db_dir));
+    EXPECT_TRUE(base::PathExists(origin1_db_dir));
+    EXPECT_TRUE(base::PathExists(origin2_db_dir));
   }
 
   static void EmptyDatabaseNameIsValid() {
     const GURL kOrigin(kOrigin1Url);
     const std::string kOriginId =
         webkit_database::GetIdentifierFromOrigin(kOrigin);
     const base::string16 kEmptyName;
     const base::string16 kDescription(ASCIIToUTF16("description"));
     const base::string16 kChangedDescription(
         ASCIIToUTF16("changed_description"));
@@ skipping 76 matching lines @@
     // Verify does no harm with a non-error is reported.
     tracker->HandleSqliteError(kOriginId, kName, SQLITE_OK);
     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
     EXPECT_FALSE(observer.DidReceiveNewNotification());
 
     // Verify that with a connection open, the db is scheduled for deletion,
     // but that the file still exists.
     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
     EXPECT_TRUE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
     EXPECT_TRUE(observer.DidReceiveNewNotification());
-    EXPECT_TRUE(file_util::PathExists(spoof_db_file));
+    EXPECT_TRUE(base::PathExists(spoof_db_file));
 
     // Verify that once closed, the file is deleted and the record in the
     // tracker db is removed.
     tracker->DatabaseClosed(kOriginId, kName);
-    EXPECT_FALSE(file_util::PathExists(spoof_db_file));
+    EXPECT_FALSE(base::PathExists(spoof_db_file));
     EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
 
     // --------------------------------------------------------
     // Create another record of a database in the tracker db and create
     // a spoof_db_file on disk in the expected location.
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
     base::FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId, kName);
     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
     EXPECT_NE(spoof_db_file, spoof_db_file2);
     EXPECT_TRUE(file_util::CreateDirectory(spoof_db_file2.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(spoof_db_file2, 1));
 
     // Verify that with no connection open, the db is deleted immediately.
     tracker->DatabaseClosed(kOriginId, kName);
     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
     EXPECT_FALSE(observer.DidReceiveNewNotification());
     EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
-    EXPECT_FALSE(file_util::PathExists(spoof_db_file2));
+    EXPECT_FALSE(base::PathExists(spoof_db_file2));
 
     tracker->RemoveObserver(&observer);
   }
 };
 
 TEST(DatabaseTrackerTest, DeleteOpenDatabase) {
   DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(false);
 }
 
 TEST(DatabaseTrackerTest, DeleteOpenDatabaseIncognitoMode) {
@@ skipping 26 matching lines @@
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
 }  // namespace webkit_database