Add FilePath to base namespace.

webkit/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_path.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 140 matching lines @@
   // Map from origin to <count, sum of deltas>
   std::map<GURL, std::pair<int, int64> > modifications_;
 
  protected:
   virtual ~TestQuotaManagerProxy() {
     EXPECT_FALSE(registered_client_);
   }
 };
 
 
-bool EnsureFileOfSize(const FilePath& file_path, int64 length) {
+bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) {
   base::PlatformFileError error_code(base::PLATFORM_FILE_ERROR_FAILED);
   base::PlatformFile file =
       base::CreatePlatformFile(
           file_path,
           base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE,
           NULL,
           &error_code);
   if (error_code != base::PLATFORM_FILE_OK)
     return false;
   if (!base::TruncatePlatformFile(file, length))
@@ skipping 36 matching lines @@
     const string16 kDescription = ASCIIToUTF16("database_description");
 
     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                             &database_size);
     tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
                             &database_size);
     tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0,
                             &database_size);
 
     EXPECT_TRUE(file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
-        FilePath::FromWStringHack(UTF16ToWide(
+        base::FilePath::FromWStringHack(UTF16ToWide(
             tracker->GetOriginDirectory(kOrigin1))))));
     EXPECT_TRUE(file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
-        FilePath::FromWStringHack(UTF16ToWide(
+        base::FilePath::FromWStringHack(UTF16ToWide(
             tracker->GetOriginDirectory(kOrigin2))))));
     EXPECT_EQ(1, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
     EXPECT_EQ(2, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
     EXPECT_EQ(3, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin2, kDB3), "aaa", 3));
     tracker->DatabaseModified(kOrigin1, kDB1);
     tracker->DatabaseModified(kOrigin2, kDB2);
     tracker->DatabaseModified(kOrigin2, kDB3);
 
     // Delete db1. Should also delete origin1.
     TestObserver observer;
     tracker->AddObserver(&observer);
     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(tracker->DatabaseDirectory().Append(
-        FilePath::FromWStringHack(UTF16ToWide(kOrigin1)))));
+        base::FilePath::FromWStringHack(UTF16ToWide(kOrigin1)))));
 
     // Recreate db1.
     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                             &database_size);
     EXPECT_TRUE(file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
-        FilePath::FromWStringHack(UTF16ToWide(
+        base::FilePath::FromWStringHack(UTF16ToWide(
             tracker->GetOriginDirectory(kOrigin1))))));
     EXPECT_EQ(1, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
     tracker->DatabaseModified(kOrigin1, kDB1);
 
     // Setup file modification times.  db1 and db2 are modified now, db3 three
     // days ago.
     EXPECT_TRUE(file_util::SetLastModifiedTime(
         tracker->GetFullDBFilePath(kOrigin1, kDB1), base::Time::Now()));
     EXPECT_TRUE(file_util::SetLastModifiedTime(
         tracker->GetFullDBFilePath(kOrigin2, kDB2), base::Time::Now()));
     base::Time three_days_ago = base::Time::Now();
     three_days_ago -= base::TimeDelta::FromDays(3);
     EXPECT_TRUE(file_util::SetLastModifiedTime(
         tracker->GetFullDBFilePath(kOrigin2, kDB3), three_days_ago));
 
     // Delete databases modified since yesterday. db2 is whitelisted.
     base::Time yesterday = base::Time::Now();
     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(tracker->DatabaseDirectory().Append(
-        FilePath::FromWStringHack(UTF16ToWide(kOrigin1)))));
+        base::FilePath::FromWStringHack(UTF16ToWide(kOrigin1)))));
     EXPECT_TRUE(
         file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
     EXPECT_TRUE(
         file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
 
     tracker->DatabaseClosed(kOrigin2, kDB3);
     tracker->RemoveObserver(&observer);
   }
 
   static void TestDatabaseTracker(bool incognito_mode) {
@@ skipping 39 matching lines @@
     tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
                             &database_size);
     EXPECT_EQ(0, database_size);
     tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
                             &database_size);
     EXPECT_EQ(0, database_size);
 
     // Write some data to each file and check that the listeners are
     // called with the appropriate values.
     EXPECT_TRUE(file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
-        FilePath::FromWStringHack(UTF16ToWide(
+        base::FilePath::FromWStringHack(UTF16ToWide(
             tracker->GetOriginDirectory(kOrigin1))))));
     EXPECT_TRUE(file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
-        FilePath::FromWStringHack(UTF16ToWide(
+        base::FilePath::FromWStringHack(UTF16ToWide(
             tracker->GetOriginDirectory(kOrigin2))))));
     EXPECT_EQ(1, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
     EXPECT_EQ(2, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
     EXPECT_EQ(4, file_util::WriteFile(
         tracker->GetFullDBFilePath(kOrigin1, kDB3), "aaaa", 4));
     tracker->DatabaseModified(kOrigin1, kDB1);
     CheckNotificationReceived(&observer1, kOrigin1, kDB1, 1);
     CheckNotificationReceived(&observer2, kOrigin1, kDB1, 1);
@@ skipping 97 matching lines @@
 
     // Create a database and modify it a couple of times, close it,
     // then delete it. Observe the tracker notifies accordingly.
 
     int64 database_size = 0;
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
     test_quota_proxy->reset();
 
-    FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
+    base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
     EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
     tracker->DatabaseModified(kOriginId, kName);
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
     test_quota_proxy->reset();
 
     EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
     tracker->DatabaseModified(kOriginId, kName);
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 90));
     test_quota_proxy->reset();
@@ skipping 61 matching lines @@
     const string16 kOrigin2 =
         DatabaseUtil::GetOriginIdentifier(GURL(kOrigin2Url));
     const string16 kDB1 = ASCIIToUTF16("db1");
     const string16 kDB2 = ASCIIToUTF16("db2");
     const string16 kDescription = ASCIIToUTF16("database_description");
 
     // Initialize the tracker database.
     MessageLoop message_loop;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-    FilePath origin1_db_dir;
-    FilePath origin2_db_dir;
+    base::FilePath origin1_db_dir;
+    base::FilePath origin2_db_dir;
     {
       scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
           new quota::MockSpecialStoragePolicy;
       special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
       scoped_refptr<DatabaseTracker> tracker(
           new DatabaseTracker(
               temp_dir.path(), false, special_storage_policy, NULL,
               base::MessageLoopProxy::current()));
 
       // Open two new databases.
       tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                               &database_size);
       EXPECT_EQ(0, database_size);
       tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
                               &database_size);
       EXPECT_EQ(0, database_size);
 
       // Write some data to each file.
-      FilePath db_file;
+      base::FilePath db_file;
       db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
       EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
       EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
 
       db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
       EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
       EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
 
       // Store the origin database directories as long as they still exist.
       origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
@@ skipping 15 matching lines @@
 
     // 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].GetOrigin());
     EXPECT_TRUE(
         file_util::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
-    EXPECT_EQ(FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2));
+    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));
   }
 
   static void DatabaseTrackerSetForceKeepSessionState() {
     int64 database_size = 0;
     const string16 kOrigin1 =
         DatabaseUtil::GetOriginIdentifier(GURL(kOrigin1Url));
     const string16 kOrigin2 =
         DatabaseUtil::GetOriginIdentifier(GURL(kOrigin2Url));
     const string16 kDB1 = ASCIIToUTF16("db1");
     const string16 kDB2 = ASCIIToUTF16("db2");
     const string16 kDescription = ASCIIToUTF16("database_description");
 
     // Initialize the tracker database.
     MessageLoop message_loop;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-    FilePath origin1_db_dir;
-    FilePath origin2_db_dir;
+    base::FilePath origin1_db_dir;
+    base::FilePath origin2_db_dir;
     {
       scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
           new quota::MockSpecialStoragePolicy;
       special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
       scoped_refptr<DatabaseTracker> tracker(
           new DatabaseTracker(
               temp_dir.path(), false, special_storage_policy, NULL,
               base::MessageLoopProxy::current()));
       tracker->SetForceKeepSessionState();
 
       // Open two new databases.
       tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                               &database_size);
       EXPECT_EQ(0, database_size);
       tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
                               &database_size);
       EXPECT_EQ(0, database_size);
 
       // Write some data to each file.
-      FilePath db_file;
+      base::FilePath db_file;
       db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
       EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
       EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
 
       db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
       EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
       EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
 
       // Store the origin database directories as long as they still exist.
       origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
@@ skipping 96 matching lines @@
     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
     EXPECT_FALSE(observer.DidReceiveNewNotification());
 
     // --------------------------------------------------------
     // Create a record of a database in the tracker db and create
     // a spoof_db_file on disk in the expected location.
     int64 database_size = 0;
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
-    FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName);
+    base::FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName);
     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
     EXPECT_TRUE(file_util::CreateDirectory(spoof_db_file.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(spoof_db_file, 1));
 
     // 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));
 
     // 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_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);
-    FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId, kName);
+    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());
@@ skipping 38 matching lines @@
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
 }  // namespace webkit_database