Move directory creation functions 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/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 211 matching lines @@
     const base::string16 kDB3 = ASCIIToUTF16("db3");
     const base::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(
+    EXPECT_TRUE(base::CreateDirectory(
         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
             tracker->GetOriginDirectory(kOrigin1)))));
-    EXPECT_TRUE(file_util::CreateDirectory(
+    EXPECT_TRUE(base::CreateDirectory(
         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
             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);
@@ skipping 11 matching lines @@
     EXPECT_EQ(kDB1, observer.GetNotificationDatabaseName());
     tracker->DatabaseClosed(kOrigin1, kDB1);
     result = callback.GetResult(result);
     EXPECT_EQ(net::OK, result);
     EXPECT_FALSE(base::PathExists(
           tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
 
     // Recreate db1.
     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                             &database_size);
-    EXPECT_TRUE(file_util::CreateDirectory(
+    EXPECT_TRUE(base::CreateDirectory(
         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
             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()));
@@ skipping 72 matching lines @@
     EXPECT_EQ(0, database_size);
     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(
+    EXPECT_TRUE(base::CreateDirectory(
         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
             tracker->GetOriginDirectory(kOrigin1)))));
-    EXPECT_TRUE(file_util::CreateDirectory(
+    EXPECT_TRUE(base::CreateDirectory(
         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
             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);
@@ skipping 103 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();
 
     base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
-    EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+    EXPECT_TRUE(base::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();
 
     tracker->DatabaseClosed(kOriginId, kName);
     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
     EXPECT_EQ(net::OK, tracker->DeleteDatabase(
         kOriginId, kName, net::CompletionCallback()));
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
     test_quota_proxy->reset();
 
     // Create a database and modify it, try to delete it while open,
     // then close it (at which time deletion will actually occur).
     // Observe the tracker notifies accordingly.
 
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
     test_quota_proxy->reset();
 
     db_file = tracker->GetFullDBFilePath(kOriginId, kName);
-    EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+    EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
     tracker->DatabaseModified(kOriginId, kName);
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
     test_quota_proxy->reset();
 
     EXPECT_EQ(net::ERR_IO_PENDING,
               tracker->DeleteDatabase(kOriginId, kName,
                                       net::CompletionCallback()));
     EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
 
     tracker->DatabaseClosed(kOriginId, kName);
     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
     test_quota_proxy->reset();
 
     // Create a database and up the file size without telling
     // the tracker about the modification, than simulate a
     // a renderer crash.
     // Observe the tracker notifies accordingly.
 
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
     test_quota_proxy->reset();
     db_file = tracker->GetFullDBFilePath(kOriginId, kName);
-    EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+    EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
     DatabaseConnections crashed_renderer_connections;
     crashed_renderer_connections.AddConnection(kOriginId, kName);
     EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
     tracker->CloseDatabases(crashed_renderer_connections);
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
 
     // Cleanup.
     crashed_renderer_connections.RemoveAllConnections();
     test_quota_proxy->SimulateQuotaManagerDestroyed();
@@ skipping 30 matching lines @@
       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.
       base::FilePath db_file;
       db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
-      EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+      EXPECT_TRUE(base::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(base::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();
       origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
 
       tracker->DatabaseModified(kOrigin1, kDB1);
       tracker->DatabaseModified(kOrigin2, kDB2);
 
       // Close all databases.
@@ skipping 56 matching lines @@
       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.
       base::FilePath db_file;
       db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
-      EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+      EXPECT_TRUE(base::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(base::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();
       origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
 
       tracker->DatabaseModified(kOrigin1, kDB1);
       tracker->DatabaseModified(kOrigin2, kDB2);
 
       // Close all databases.
@@ skipping 95 matching lines @@
     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);
     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(base::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(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(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(base::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(base::PathExists(spoof_db_file2));
 
@@ skipping 35 matching lines @@
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
 }  // namespace webkit_database