Final part of PathString cleanup.

chrome/browser/sync/syncable/syncable.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/stat.h>
 #if defined(OS_POSIX)
@@ skipping 103 matching lines @@
 template <Int64Field field_index>
 class HashField {
  public:
   inline size_t operator()(const syncable::EntryKernel* a) const {
     return hasher_(a->ref(field_index));
   }
   base::hash_set<int64> hasher_;
 };
 
 // TODO(chron): Remove this function.
-int ComparePathNames(const PathString& a, const PathString& b) {
-  const size_t val_size = sizeof(PathString::value_type);
+int ComparePathNames(const string& a, const string& b) {
+  const size_t val_size = sizeof(string::value_type);
   return ComparePathNames16(NULL, a.size() * val_size, a.data(),
                                   b.size() * val_size, b.data());
 }
 
 class LessParentIdAndHandle {
  public:
   bool operator() (const syncable::EntryKernel* a,
                    const syncable::EntryKernel* b) const {
     if (a->ref(PARENT_ID) != b->ref(PARENT_ID)) {
       return a->ref(PARENT_ID) < b->ref(PARENT_ID);
     }
 
     // Meta handles are immutable per entry so this is ideal.
     return a->ref(META_HANDLE) < b->ref(META_HANDLE);
   }
 };
 
 // TODO(chron): Remove this function.
-bool LessPathNames::operator() (const PathString& a,
-                                const PathString& b) const {
+bool LessPathNames::operator() (const string& a, const string& b) const {
   return ComparePathNames(a, b) < 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Directory
 
 static const DirectoryChangeEvent kShutdownChangesEvent =
     { DirectoryChangeEvent::SHUTDOWN, 0, 0 };
 
 Directory::Kernel::Kernel(const FilePath& db_path,
-                          const PathString& name,
+                          const string& name,
                           const KernelLoadInfo& info)
-: db_path(db_path),
-  refcount(1),
-  name_(name),
-  metahandles_index(new Directory::MetahandlesIndex),
-  ids_index(new Directory::IdsIndex),
-  parent_id_child_index(new Directory::ParentIdChildIndex),
-  extended_attributes(new ExtendedAttributes),
-  unapplied_update_metahandles(new MetahandleSet),
-  unsynced_metahandles(new MetahandleSet),
-  channel(new Directory::Channel(syncable::DIRECTORY_DESTROYED)),
-  changes_channel(new Directory::ChangesChannel(kShutdownChangesEvent)),
-  last_sync_timestamp_(info.kernel_info.last_sync_timestamp),
-  initial_sync_ended_(info.kernel_info.initial_sync_ended),
-  store_birthday_(info.kernel_info.store_birthday),
-  cache_guid_(info.cache_guid),
-  next_metahandle(info.max_metahandle + 1),
-  next_id(info.kernel_info.next_id) {
+    : db_path(db_path),
+      refcount(1),
+      name_(name),
+      metahandles_index(new Directory::MetahandlesIndex),
+      ids_index(new Directory::IdsIndex),
+      parent_id_child_index(new Directory::ParentIdChildIndex),
+      extended_attributes(new ExtendedAttributes),
+      unapplied_update_metahandles(new MetahandleSet),
+      unsynced_metahandles(new MetahandleSet),
+      channel(new Directory::Channel(syncable::DIRECTORY_DESTROYED)),
+      changes_channel(new Directory::ChangesChannel(kShutdownChangesEvent)),
+      last_sync_timestamp_(info.kernel_info.last_sync_timestamp),
+      initial_sync_ended_(info.kernel_info.initial_sync_ended),
+      store_birthday_(info.kernel_info.store_birthday),
+      cache_guid_(info.cache_guid),
+      next_metahandle(info.max_metahandle + 1),
+      next_id(info.kernel_info.next_id) {
   info_status_ = Directory::KERNEL_SHARE_INFO_VALID;
 }
 
 inline void DeleteEntry(EntryKernel* kernel) {
   delete kernel;
 }
 
 void Directory::Kernel::AddRef() {
   base::subtle::NoBarrier_AtomicIncrement(&refcount, 1);
 }
@@ skipping 16 matching lines @@
   delete metahandles_index;
 }
 
 Directory::Directory() : kernel_(NULL), store_(NULL) {
 }
 
 Directory::~Directory() {
   Close();
 }
 
-DirOpenResult Directory::Open(const FilePath& file_path,
-                              const PathString& name) {
+DirOpenResult Directory::Open(const FilePath& file_path, const string& name) {
   const DirOpenResult result = OpenImpl(file_path, name);
   if (OPENED != result)
     Close();
   return result;
 }
 
 void Directory::InitializeIndices() {
   MetahandlesIndex::iterator it = kernel_->metahandles_index->begin();
   for (; it != kernel_->metahandles_index->end(); ++it) {
     EntryKernel* entry = *it;
     if (!entry->ref(IS_DEL))
       kernel_->parent_id_child_index->insert(entry);
     kernel_->ids_index->insert(entry);
     if (entry->ref(IS_UNSYNCED))
       kernel_->unsynced_metahandles->insert(entry->ref(META_HANDLE));
     if (entry->ref(IS_UNAPPLIED_UPDATE))
       kernel_->unapplied_update_metahandles->insert(entry->ref(META_HANDLE));
   }
 }
 
 DirectoryBackingStore* Directory::CreateBackingStore(
-    const PathString& dir_name, const FilePath& backing_filepath) {
+    const string& dir_name, const FilePath& backing_filepath) {
   return new DirectoryBackingStore(dir_name, backing_filepath);
 }
 
 DirOpenResult Directory::OpenImpl(const FilePath& file_path,
-                                  const PathString& name) {
+                                  const string& name) {
   DCHECK_EQ(static_cast<DirectoryBackingStore*>(NULL), store_);
   FilePath db_path(file_path);
   file_util::AbsolutePath(&db_path);
   store_ = CreateBackingStore(name, db_path);
 
   KernelLoadInfo info;
   // Temporary indices before kernel_ initialized in case Load fails. We 0(1)
   // swap these later.
   MetahandlesIndex metas_bucket;
   ExtendedAttributes xattrs_bucket;
@@ skipping 32 matching lines @@
   // First look up in memory
   kernel_->needle.ref(ID) = id;
   IdsIndex::iterator id_found = kernel_->ids_index->find(&kernel_->needle);
   if (id_found != kernel_->ids_index->end()) {
     // Found it in memory.  Easy.
     return *id_found;
   }
   return NULL;
 }
 
-EntryKernel* Directory::GetEntryByTag(const PathString& tag) {
+EntryKernel* Directory::GetEntryByTag(const string& tag) {
   ScopedKernelLock lock(this);
   DCHECK(kernel_);
   // We don't currently keep a separate index for the tags.  Since tags
   // only exist for server created items that are the first items
   // to be created in a store, they should have small metahandles.
   // So, we just iterate over the items in sorted metahandle order,
   // looking for a match.
   MetahandlesIndex& set = *kernel_->metahandles_index;
   for (MetahandlesIndex::iterator i = set.begin(); i != set.end(); ++i) {
     if ((*i)->ref(SINGLETON_TAG) == tag) {
@@ skipping 677 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Entry
 
 Entry::Entry(BaseTransaction* trans, GetById, const Id& id)
     : basetrans_(trans) {
   kernel_ = trans->directory()->GetEntryById(id);
 }
 
-Entry::Entry(BaseTransaction* trans, GetByTag, const PathString& tag)
+Entry::Entry(BaseTransaction* trans, GetByTag, const string& tag)
     : basetrans_(trans) {
   kernel_ = trans->directory()->GetEntryByTag(tag);
 }
 
 Entry::Entry(BaseTransaction* trans, GetByHandle, int64 metahandle)
     : basetrans_(trans) {
   kernel_ = trans->directory()->GetEntryByHandle(metahandle);
 }
 
 Directory* Entry::dir() const {
   return basetrans_->directory();
 }
 
-PathString Entry::Get(StringField field) const {
+const string& Entry::Get(StringField field) const {
   DCHECK(kernel_);
   return kernel_->ref(field);
 }
 
 void Entry::GetAllExtendedAttributes(BaseTransaction* trans,
     std::set<ExtendedAttribute> *result) {
   dir()->GetAllExtendedAttributes(trans, kernel_->ref(META_HANDLE), result);
 }
 
 void Entry::GetExtendedAttributesList(BaseTransaction* trans,
     AttributeKeySet* result) {
   dir()->GetExtendedAttributesList(trans, kernel_->ref(META_HANDLE), result);
 }
 
 void Entry::DeleteAllExtendedAttributes(WriteTransaction *trans) {
   dir()->DeleteAllExtendedAttributes(trans, kernel_->ref(META_HANDLE));
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // MutableEntry
 
 MutableEntry::MutableEntry(WriteTransaction* trans, Create,
-                           const Id& parent_id, const PathString& name)
+                           const Id& parent_id, const string& name)
     : Entry(trans),
       write_transaction_(trans) {
   Init(trans, parent_id, name);
 }
 
 
 void MutableEntry::Init(WriteTransaction* trans, const Id& parent_id,
-                        const PathString& name) {
+                        const string& name) {
   kernel_ = new EntryKernel;
   ZeroFields(kernel_, BEGIN_FIELDS);
   kernel_->ref(ID) = trans->directory_->NextId();
   kernel_->dirty[ID] = true;
   kernel_->ref(META_HANDLE) = trans->directory_->NextMetahandle();
   kernel_->dirty[META_HANDLE] = true;
   kernel_->ref(PARENT_ID) = parent_id;
   kernel_->dirty[PARENT_ID] = true;
   kernel_->ref(NON_UNIQUE_NAME) = name;
   kernel_->dirty[NON_UNIQUE_NAME] = true;
@@ skipping 90 matching lines @@
 
 bool MutableEntry::Put(BaseVersion field, int64 value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     kernel_->ref(field) = value;
     kernel_->dirty[static_cast<int>(field)] = true;
   }
   return true;
 }
 
-bool MutableEntry::Put(StringField field, const PathString& value) {
+bool MutableEntry::Put(StringField field, const string& value) {
   return PutImpl(field, value);
 }
 
-bool MutableEntry::PutImpl(StringField field, const PathString& value) {
+bool MutableEntry::PutImpl(StringField field, const string& value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     kernel_->ref(field) = value;
     kernel_->dirty[static_cast<int>(field)] = true;
   }
   return true;
 }
 
 bool MutableEntry::Put(IndexedBitField field, bool value) {
   DCHECK(kernel_);
@@ skipping 181 matching lines @@
     if (entry_id == ancestor_id)
       return false;
     Entry new_parent(trans, GET_BY_ID, ancestor_id);
     CHECK(new_parent.good());
     ancestor_id = new_parent.Get(PARENT_ID);
   }
   return true;
 }
 
 const Blob* GetExtendedAttributeValue(const Entry& e,
-                                      const PathString& attribute_name) {
+                                      const string& attribute_name) {
   ExtendedAttributeKey key(e.Get(META_HANDLE), attribute_name);
   ExtendedAttribute extended_attribute(e.trans(), GET_BY_HANDLE, key);
   if (extended_attribute.good() && !extended_attribute.is_deleted())
     return &extended_attribute.value();
   return NULL;
 }
 
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e) {
   DCHECK_NE(static_cast<MutableEntry*>(NULL), e);
@@ skipping 51 matching lines @@
   for ( ; i < ID_FIELDS_END; ++i) {
     s << g_metas_columns[i].name << colon
       << kernel->ref(static_cast<IdField>(i)) << separator;
   }
   s << "Flags: ";
   for ( ; i < BIT_FIELDS_END; ++i) {
     if (kernel->ref(static_cast<BitField>(i)))
       s << g_metas_columns[i].name << separator;
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
-    const PathString& field = kernel->ref(static_cast<StringField>(i));
+    const string& field = kernel->ref(static_cast<StringField>(i));
     s << g_metas_columns[i].name << colon << field << separator;
   }
   for ( ; i < BLOB_FIELDS_END; ++i) {
     s << g_metas_columns[i].name << colon
       << kernel->ref(static_cast<BlobField>(i)) << separator;
   }
   s << "TempFlags: ";
   for ( ; i < BIT_TEMPS_END; ++i) {
     if (kernel->ref(static_cast<BitTemp>(i)))
       s << "#" << i - BIT_TEMPS_BEGIN << separator;
   }
   return stream;
 }
 
 std::ostream& operator<<(std::ostream& s, const syncable::Blob& blob) {
   for (syncable::Blob::const_iterator i = blob.begin(); i != blob.end(); ++i)
     s << std::hex << std::setw(2)
       << std::setfill('0') << static_cast<unsigned int>(*i);
   return s << std::dec;
 }
 
 FastDump& operator<<(FastDump& dump, const syncable::Blob& blob) {
   if (blob.empty())
     return dump;
   string buffer(HexEncode(&blob[0], blob.size()));
   dump.out_->sputn(buffer.c_str(), buffer.size());
   return dump;
 }