String cleanup in sync code

chrome/browser/sync/syncable/syncable_unittest.cc

 // Copyright (c) 2009 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/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/types.h>
 
@@ skipping 12 matching lines @@
 #if !defined(OS_WIN)
 #define MAX_PATH PATH_MAX
 #include <ostream>
 #include <stdio.h>
 #include <sys/ipc.h>
 #include <sys/sem.h>
 #include <sys/times.h>
 #endif  // !defined(OS_WIN)
 
 #include "base/at_exit.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/platform_thread.h"
 #include "base/scoped_ptr.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/util/closure.h"
-#include "chrome/browser/sync/util/compat_file.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 #include "chrome/browser/sync/util/query_helpers.h"
 #include "chrome/test/sync/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/preprocessed/sqlite3.h"
 
 using browser_sync::TestIdFactory;
 using std::cout;
 using std::endl;
@@ skipping 21 matching lines @@
   ExtendedAttributeKey key(e->Get(META_HANDLE), PSTR("DATA"));
   ExtendedAttribute attr(trans, GET_BY_HANDLE, key);
   EXPECT_FALSE(attr.is_deleted());
   EXPECT_EQ(expected_value, attr.value());
 }
 
 
 TEST(Syncable, General) {
   remove("SimpleTest.sqlite3");
   Directory dir;
-  dir.Open(PSTR("SimpleTest.sqlite3"), PSTR("SimpleTest"));
+  FilePath test_db(FILE_PATH_LITERAL("SimpleTest.sqlite3"));
+  dir.Open(test_db, PSTR("SimpleTest"));
   bool entry_exists = false;
   int64 metahandle;
   const Id id = TestIdFactory::FromNumber(99);
   // Test simple read operations.
   {
     ReadTransaction rtrans(&dir, __FILE__, __LINE__);
     Entry e(&rtrans, GET_BY_ID, id);
     if (e.good()) {
       entry_exists = true;
       metahandle = e.Get(META_HANDLE);
@@ skipping 77 matching lines @@
 }
 
 namespace {
 
 // A Directory whose backing store always fails SaveChanges by returning false.
 class TestUnsaveableDirectory : public Directory {
  public:
   class UnsaveableBackingStore : public DirectoryBackingStore {
    public:
      UnsaveableBackingStore(const PathString& dir_name,
-                            const PathString& backing_filepath)
+                            const FilePath& backing_filepath)
          : DirectoryBackingStore(dir_name, backing_filepath) { }
      virtual bool SaveChanges(const Directory::SaveChangesSnapshot& snapshot) {
        return false;
      }
   };
   virtual DirectoryBackingStore* CreateBackingStore(
-      const PathString& dir_name, const PathString& backing_filepath) {
+      const PathString& dir_name, const FilePath& backing_filepath) {
     return new UnsaveableBackingStore(dir_name, backing_filepath);
   }
 };
 
 // Test suite for syncable::Directory.
 class SyncableDirectoryTest : public testing::Test {
  protected:
-  static const PathString kFilePath;
+  static const FilePath::CharType kFilePath[];
   static const PathString kName;
-  static const PathChar* kSqlite3File;
   static const Id kId;
 
   // SetUp() is called before each test case is run.
   // The sqlite3 DB is deleted before each test is run.
   virtual void SetUp() {
-    PathRemove(PathString(kSqlite3File));
+    file_path_ = FilePath(kFilePath);
+    file_util::Delete(file_path_, true);
     dir_.reset(new Directory());
     ASSERT_TRUE(dir_.get());
-    ASSERT_TRUE(OPENED == dir_->Open(kFilePath, kName));
+    ASSERT_TRUE(OPENED == dir_->Open(file_path_, kName));
     ASSERT_TRUE(dir_->good());
   }
 
   virtual void TearDown() {
     // This also closes file handles.
     dir_->SaveChanges();
     dir_.reset();
-    PathRemove(PathString(kSqlite3File));
+    file_util::Delete(file_path_, true);
   }
 
   scoped_ptr<Directory> dir_;
+  FilePath file_path_;
 
   // Creates an empty entry and sets the ID field to the default kId.
   void CreateEntry(const PathString &entryname) {
     CreateEntry(entryname, kId);
   }
 
   // Creates an empty entry and sets the ID field to id.
   void CreateEntry(const PathString &entryname, const int id) {
     CreateEntry(entryname, TestIdFactory::FromNumber(id));
   }
   void CreateEntry(const PathString &entryname, Id id) {
     WriteTransaction wtrans(dir_.get(), UNITTEST, __FILE__, __LINE__);
     MutableEntry me(&wtrans, CREATE, wtrans.root_id(), entryname);
     ASSERT_TRUE(me.good());
     me.Put(ID, id);
     me.Put(IS_UNSYNCED, true);
   }
 
   void ValidateEntry(BaseTransaction* trans, int64 id, bool check_name,
       PathString name, int64 base_version, int64 server_version, bool is_del);
   void CreateAndCheck(WriteTransaction* trans, int64 parent_id, int64 id,
       PathString name, PathString server_name, int64 version,
       bool set_server_fields, bool is_dir, bool add_to_lru, int64 *meta_handle);
 };
 
-const PathString SyncableDirectoryTest::kFilePath(PSTR("Test.sqlite3"));
-const PathChar* SyncableDirectoryTest::kSqlite3File(PSTR("Test.sqlite3"));
+const FilePath::CharType SyncableDirectoryTest::kFilePath[] =
+    FILE_PATH_LITERAL("Test.sqlite3");
 const PathString SyncableDirectoryTest::kName(PSTR("Foo"));
 const Id SyncableDirectoryTest::kId(TestIdFactory::FromNumber(-99));
 
 TEST_F(SyncableDirectoryTest, TestBasicLookupNonExistantID) {
   ReadTransaction rtrans(dir_.get(), __FILE__, __LINE__);
   Entry e(&rtrans, GET_BY_ID, kId);
   ASSERT_FALSE(e.good());
 }
 
 TEST_F(SyncableDirectoryTest, TestBasicLookupValidID) {
@@ skipping 30 matching lines @@
   ASSERT_FALSE(e1.Put(IS_DEL, false));
   ASSERT_FALSE(e2.Put(IS_DEL, false));
   ASSERT_TRUE(e3.Put(IS_DEL, true));
 
   ASSERT_TRUE(e1.Put(IS_DEL, false));
   ASSERT_FALSE(e2.Put(IS_DEL, false));
   ASSERT_FALSE(e3.Put(IS_DEL, false));
   ASSERT_TRUE(e1.Put(IS_DEL, true));
 }
 
-TEST_F(SyncableDirectoryTest, TestGetFullPathNeverCrashes) {
-  PathString dirname = PSTR("honey"),
-      childname = PSTR("jelly");
-  WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
-  MutableEntry e1(&trans, CREATE, trans.root_id(), dirname);
-  ASSERT_TRUE(e1.good());
-  ASSERT_TRUE(e1.Put(IS_DIR, true));
-  MutableEntry e2(&trans, CREATE, e1.Get(ID), childname);
-  ASSERT_TRUE(e2.good());
-  PathString path = GetFullPath(&trans, e2);
-  ASSERT_FALSE(path.empty());
-  // Give the child a parent that doesn't exist.
-  e2.Put(PARENT_ID, TestIdFactory::FromNumber(42));
-  path = GetFullPath(&trans, e2);
-  ASSERT_TRUE(path.empty());
-  // Done testing, make sure CheckTreeInvariants doesn't choke.
-  e2.Put(PARENT_ID, e1.Get(ID));
-  e2.Put(IS_DEL, true);
-  e1.Put(IS_DEL, true);
-}
-
 TEST_F(SyncableDirectoryTest, TestGetUnsynced) {
   Directory::UnsyncedMetaHandles handles;
   int64 handle1, handle2;
   {
     WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
 
     dir_->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_TRUE(0 == handles.size());
 
     MutableEntry e1(&trans, CREATE, trans.root_id(), PSTR("abba"));
@@ skipping 391 matching lines @@
     ASSERT_TRUE(e1.good());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(BASE_VERSION, 1);
     e1.Put(IS_DIR, true);
     e1.Put(ID, TestIdFactory::FromNumber(101));
   }
   ASSERT_TRUE(dir_->SaveChanges());
 
   dir_.reset(new TestUnsaveableDirectory());
   ASSERT_TRUE(dir_.get());
-  ASSERT_TRUE(OPENED == dir_->Open(kFilePath, kName));
+  ASSERT_TRUE(OPENED == dir_->Open(FilePath(kFilePath), kName));
   ASSERT_TRUE(dir_->good());
   int64 handle2 = 0;
   {
     WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
 
     MutableEntry aguilera(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(aguilera.good());
     aguilera.Put(NAME, PSTR("christina"));
     ASSERT_TRUE(aguilera.GetKernelCopy().dirty[NAME]);
 
@@ skipping 31 matching lines @@
   Entry e(trans, GET_BY_ID, TestIdFactory::FromNumber(id));
   ASSERT_TRUE(e.good());
   if (check_name)
     ASSERT_TRUE(name == e.Get(NAME));
   ASSERT_TRUE(base_version == e.Get(BASE_VERSION));
   ASSERT_TRUE(server_version == e.Get(SERVER_VERSION));
   ASSERT_TRUE(is_del == e.Get(IS_DEL));
 }
 
 TEST(SyncableDirectoryManager, TestFileRelease) {
-  DirectoryManager dm(PSTR("."));
+  DirectoryManager dm(FilePath(FILE_PATH_LITERAL(".")));
   ASSERT_TRUE(dm.Open(PSTR("ScopeTest")));
   {
     ScopedDirLookup(&dm, PSTR("ScopeTest"));
   }
   dm.Close(PSTR("ScopeTest"));
-  ASSERT_TRUE(0 == PathRemove(dm.GetSyncDataDatabasePath()));
+  ASSERT_TRUE(file_util::Delete(dm.GetSyncDataDatabasePath(), true));
 }
 
 class ThreadOpenTestDelegate : public PlatformThread::Delegate {
   public:
    explicit ThreadOpenTestDelegate(DirectoryManager* dm)
        : directory_manager_(dm) {}
    DirectoryManager* const directory_manager_;
 
   private:
    // PlatformThread::Delegate methods:
    virtual void ThreadMain() {
     CHECK(directory_manager_->Open(PSTR("Open")));
    }
 
   DISALLOW_COPY_AND_ASSIGN(ThreadOpenTestDelegate);
 };
 
 TEST(SyncableDirectoryManager, ThreadOpenTest) {
-  DirectoryManager dm(PSTR("."));
+  DirectoryManager dm(FilePath(FILE_PATH_LITERAL(".")));
   PlatformThreadHandle thread_handle;
   ThreadOpenTestDelegate test_delegate(&dm);
   ASSERT_TRUE(PlatformThread::Create(0, &test_delegate, &thread_handle));
   PlatformThread::Join(thread_handle);
   {
     ScopedDirLookup dir(&dm, PSTR("Open"));
     ASSERT_TRUE(dir.good());
   }
   dm.Close(PSTR("Open"));
   ScopedDirLookup dir(&dm, PSTR("Open"));
@@ skipping 60 matching lines @@
        step_->condvar.Signal();
      }
    }
 
   DISALLOW_COPY_AND_ASSIGN(ThreadBugDelegate);
 };
 
 TEST(SyncableDirectoryManager, ThreadBug1) {
   Step step;
   step.number = 0;
-  DirectoryManager dirman(PSTR("."));
+  DirectoryManager dirman(FilePath(FILE_PATH_LITERAL(".")));
   ThreadBugDelegate thread_delegate_1(0, &step, &dirman);
   ThreadBugDelegate thread_delegate_2(1, &step, &dirman);
 
   PlatformThreadHandle thread_handle_1;
   PlatformThreadHandle thread_handle_2;
 
   ASSERT_TRUE(PlatformThread::Create(0, &thread_delegate_1, &thread_handle_1));
   ASSERT_TRUE(PlatformThread::Create(0, &thread_delegate_2, &thread_handle_2));
 
   PlatformThread::Join(thread_handle_1);
@@ skipping 16 matching lines @@
     AutoLock scoped_lock(step_->mutex);
 
     while (step_->number < 4) {
       while (step_->number % 2 != role_) {
         step_->condvar.Wait();
       }
       switch (step_->number) {
       case 0:
         {
           // Clean up remnants of earlier test runs.
-          PathRemove(directory_manager_->GetSyncDataDatabasePath());
+          file_util::Delete(directory_manager_->GetSyncDataDatabasePath(),
+                            true);
           // Test.
           directory_manager_->Open(dirname);
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
           WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
           MutableEntry me(&trans, CREATE, trans.root_id(), PSTR("Jeff"));
           me.Put(BASE_VERSION, 1);
           me.Put(ID, TestIdFactory::FromNumber(100));
           PutDataAsExtendedAttribute(&trans, &me, test_bytes,
                                      sizeof(test_bytes));
@@ skipping 35 matching lines @@
       step_->condvar.Signal();
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(DirectoryKernelStalenessBugDelegate);
 };
 
 TEST(SyncableDirectoryManager, DirectoryKernelStalenessBug) {
   Step step;
 
-  DirectoryManager dirman(PSTR("."));
+  DirectoryManager dirman(FilePath(FILE_PATH_LITERAL(".")));
   DirectoryKernelStalenessBugDelegate thread_delegate_1(0, &step, &dirman);
   DirectoryKernelStalenessBugDelegate thread_delegate_2(1, &step, &dirman);
 
   PlatformThreadHandle thread_handle_1;
   PlatformThreadHandle thread_handle_2;
 
   ASSERT_TRUE(PlatformThread::Create(0, &thread_delegate_1, &thread_handle_1));
   ASSERT_TRUE(PlatformThread::Create(0, &thread_delegate_2, &thread_handle_2));
 
   PlatformThread::Join(thread_handle_1);
@@ skipping 39 matching lines @@
            e.Get(ID).ServerKnows() && !e.Get(ID).IsRoot())
            e.Put(BASE_VERSION, 1);
        }
     }
    }
 
   DISALLOW_COPY_AND_ASSIGN(StressTransactionsDelegate);
 };
 
 TEST(SyncableDirectory, StressTransactions) {
-  DirectoryManager dirman(PSTR("."));
+  DirectoryManager dirman(FilePath(FILE_PATH_LITERAL(".")));
   PathString dirname = PSTR("stress");
-  PathRemove(dirman.GetSyncDataDatabasePath());
+  file_util::Delete(dirman.GetSyncDataDatabasePath(), true);
   dirman.Open(dirname);
 
   const int kThreadCount = 7;
   PlatformThreadHandle threads[kThreadCount];
   scoped_ptr<StressTransactionsDelegate> thread_delegates[kThreadCount];
 
   for (int i = 0; i < kThreadCount; ++i) {
     thread_delegates[i].reset(
         new StressTransactionsDelegate(&dirman, dirname, i));
     ASSERT_TRUE(
         PlatformThread::Create(0, thread_delegates[i].get(), &threads[i]));
   }
 
   for (int i = 0; i < kThreadCount; ++i) {
     PlatformThread::Join(threads[i]);
   }
 
   dirman.Close(dirname);
-  PathRemove(dirman.GetSyncDataDatabasePath());
+  file_util::Delete(dirman.GetSyncDataDatabasePath(), true);
 }
 
 TEST(Syncable, ComparePathNames) {
   struct {
     char a;
     char b;
     int expected_result;
   } tests[] = {
     { 'A', 'A', 0 },
     { 'A', 'a', 0 },
@@ skipping 65 matching lines @@
     Blob value_blob(value, value + arraysize(value));
     ext.mutable_value()->swap(value_blob);
     ext.delete_attribute();
   }
   // This call to SaveChanges used to CHECK fail.
   dir_.get()->SaveChanges();
 }
 
 }  // namespace
 }  // namespace syncable