Final part of PathString cleanup.

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 
 #include <algorithm>
 #include <bitset>
 #include <iosfwd>
@@ skipping 199 matching lines @@
 };
 
 enum Create {
   CREATE
 };
 
 enum CreateNewUpdateItem {
   CREATE_NEW_UPDATE_ITEM
 };
 
-typedef std::set<PathString> AttributeKeySet;
+typedef std::set<std::string> AttributeKeySet;
 
 // Why the singular enums?  So the code compile-time dispatches instead of
 // runtime dispatches as it would with a single enum and an if() statement.
 
 // The EntryKernel class contains the actual data for an entry.  It
 // would be a private class, except the number of required friend
 // declarations would bloat the code.
 struct EntryKernel {
  protected:
-  PathString string_fields[STRING_FIELDS_COUNT];
+  std::string string_fields[STRING_FIELDS_COUNT];
   Blob blob_fields[BLOB_FIELDS_COUNT];
   int64 int64_fields[INT64_FIELDS_COUNT];
   Id id_fields[ID_FIELDS_COUNT];
   std::bitset<BIT_FIELDS_COUNT> bit_fields;
   std::bitset<BIT_TEMPS_COUNT> bit_temps;
 
  public:
   std::bitset<FIELD_COUNT> dirty;
 
   // Contain all this error-prone arithmetic in one place.
@@ skipping 11 matching lines @@
   }
   inline std::bitset<BIT_FIELDS_COUNT>::reference ref(IndexedBitField field) {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline std::bitset<BIT_FIELDS_COUNT>::reference ref(IsDelField field) {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline std::bitset<BIT_FIELDS_COUNT>::reference ref(BitField field) {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
-  inline PathString& ref(StringField field) {
+  inline std::string& ref(StringField field) {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline Blob& ref(BlobField field) {
     return blob_fields[field - BLOB_FIELDS_BEGIN];
   }
   inline std::bitset<BIT_TEMPS_COUNT>::reference ref(BitTemp field) {
     return bit_temps[field - BIT_TEMPS_BEGIN];
   }
 
   inline int64 ref(MetahandleField field) const {
@@ skipping 10 matching lines @@
   }
   inline bool ref(IndexedBitField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline bool ref(IsDelField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline bool ref(BitField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
-  inline PathString ref(StringField field) const {
+  inline const std::string& ref(StringField field) const {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline Blob ref(BlobField field) const {
     return blob_fields[field - BLOB_FIELDS_BEGIN];
   }
   inline bool ref(BitTemp field) const {
     return bit_temps[field - BIT_TEMPS_BEGIN];
   }
 };
 
 // A read-only meta entry.
 class Entry {
   friend class Directory;
   friend std::ostream& ::operator << (std::ostream& s, const Entry& e);
 
  public:
   // After constructing, you must check good() to test whether the Get
   // succeeded.
   Entry(BaseTransaction* trans, GetByHandle, int64 handle);
   Entry(BaseTransaction* trans, GetById, const Id& id);
-  Entry(BaseTransaction* trans, GetByTag, const PathString& tag);
+  Entry(BaseTransaction* trans, GetByTag, const std::string& tag);
 
   bool good() const { return 0 != kernel_; }
 
   BaseTransaction* trans() const { return basetrans_; }
 
   // Field accessors.
   inline int64 Get(MetahandleField field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
@@ skipping 14 matching lines @@
     return kernel_->ref(field);
   }
   inline bool Get(IsDelField field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
   inline bool Get(BitField field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
-  PathString Get(StringField field) const;
+  const std::string& Get(StringField field) const;
   inline Blob Get(BlobField field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
   inline bool Get(BitTemp field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
 
   inline bool ExistsOnClientBecauseNameIsNonEmpty() const {
@@ skipping 34 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(Entry);
 };
 
 // A mutable meta entry.  Changes get committed to the database when the
 // WriteTransaction is destroyed.
 class MutableEntry : public Entry {
   friend class WriteTransaction;
   friend class Directory;
   void Init(WriteTransaction* trans, const Id& parent_id,
-      const PathString& name);
+      const std::string& name);
  public:
   MutableEntry(WriteTransaction* trans, Create, const Id& parent_id,
-               const PathString& name);
+               const std::string& name);
   MutableEntry(WriteTransaction* trans, CreateNewUpdateItem, const Id& id);
   MutableEntry(WriteTransaction* trans, GetByHandle, int64);
   MutableEntry(WriteTransaction* trans, GetById, const Id&);
 
   inline WriteTransaction* write_transaction() const {
     return write_transaction_;
   }
 
   // Field Accessors.  Some of them trigger the re-indexing of the entry.
   // Return true on success, return false on failure, which means
   // that putting the value would have caused a duplicate in the index.
   // TODO(chron): Remove some of these unecessary return values.
   bool Put(Int64Field field, const int64& value);
   bool Put(IdField field, const Id& value);
-  bool Put(StringField field, const PathString& value);
+  bool Put(StringField field, const std::string& value);
   bool Put(BaseVersion field, int64 value);
 
   inline bool Put(BlobField field, const Blob& value) {
     return PutField(field, value);
   }
   inline bool Put(BitField field, bool value) {
     return PutField(field, value);
   }
   inline bool Put(IsDelField field, bool value) {
     return PutIsDel(value);
@@ skipping 28 matching lines @@
     kernel_->ref(field) = value;
     return true;
   }
 
   bool PutIsDel(bool value);
 
  private:  // Don't allow creation on heap, except by sync API wrappers.
   friend class sync_api::WriteNode;
   void* operator new(size_t size) { return (::operator new)(size); }
 
-  bool PutImpl(StringField field, const PathString& value);
+  bool PutImpl(StringField field, const std::string& value);
 
   // Adjusts the successor and predecessor entries so that they no longer
   // refer to this entry.
   void UnlinkFromOrder();
 
   // Kind of redundant. We should reduce the number of pointers
   // floating around if at all possible. Could we store this in Directory?
   // Scope: Set on construction, never changed after that.
   WriteTransaction* const write_transaction_;
 
@@ skipping 47 matching lines @@
   BaseTransaction* trans;
   WriterTag writer;
   typedef DirectoryChangeEvent EventType;
   static inline bool IsChannelShutdownEvent(const EventType& e) {
     return SHUTDOWN == e.todo;
   }
 };
 
 struct ExtendedAttributeKey {
   int64 metahandle;
-  PathString key;
+  std::string key;
   inline bool operator < (const ExtendedAttributeKey& x) const {
     if (metahandle != x.metahandle)
       return metahandle < x.metahandle;
     return key.compare(x.key) < 0;
   }
-  ExtendedAttributeKey(int64 metahandle, PathString key) :
-      metahandle(metahandle), key(key) {  }
+  ExtendedAttributeKey(int64 metahandle, const std::string& key)
+      : metahandle(metahandle), key(key) {  }
 };
 
 struct ExtendedAttributeValue {
   Blob value;
   bool is_deleted;
   bool dirty;
 };
 
 typedef std::map<ExtendedAttributeKey, ExtendedAttributeValue>
     ExtendedAttributes;
@@ skipping 82 matching lines @@
     PersistedKernelInfo kernel_info;
     OriginalEntries dirty_metas;
     ExtendedAttributes dirty_xattrs;
     SaveChangesSnapshot() : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {
     }
   };
 
   Directory();
   virtual ~Directory();
 
-  DirOpenResult Open(const FilePath& file_path, const PathString& name);
+  DirOpenResult Open(const FilePath& file_path, const std::string& name);
 
   void Close();
 
   int64 NextMetahandle();
   // Always returns a negative id.  Positive client ids are generated
   // by the server only.
   Id NextId();
 
   const FilePath& file_path() const { return kernel_->db_path; }
   bool good() const { return NULL != store_; }
 
   // The sync timestamp is an index into the list of changes for an account.
   // It doesn't actually map to any time scale, it's name is an historical
   // anomaly.
   int64 last_sync_timestamp() const;
   void set_last_sync_timestamp(int64 timestamp);
 
   bool initial_sync_ended() const;
   void set_initial_sync_ended(bool value);
 
-  PathString name() const { return kernel_->name_; }
+  const std::string& name() const { return kernel_->name_; }
 
   // (Account) Store birthday is opaque to the client,
   // so we keep it in the format it is in the proto buffer
   // in case we switch to a binary birthday later.
   std::string store_birthday() const;
   void set_store_birthday(std::string store_birthday);
 
   // Unique to each account / client pair.
   std::string cache_guid() const;
 
  protected:  // for friends, mainly used by Entry constructors
   EntryKernel* GetEntryByHandle(const int64 handle);
   EntryKernel* GetEntryByHandle(const int64 metahandle, ScopedKernelLock* lock);
   EntryKernel* GetEntryById(const Id& id);
-  EntryKernel* GetEntryByTag(const PathString& tag);
+  EntryKernel* GetEntryByTag(const std::string& tag);
   EntryKernel* GetRootEntry();
   bool ReindexId(EntryKernel* const entry, const Id& new_id);
   void ReindexParentId(EntryKernel* const entry, const Id& new_parent_id);
 
   // These don't do semantic checking.
   // The semantic checking is implemented higher up.
   void Undelete(EntryKernel* const entry);
   void Delete(EntryKernel* const entry);
 
   // Overridden by tests.
   virtual DirectoryBackingStore* CreateBackingStore(
-      const PathString& dir_name,
+      const std::string& dir_name,
       const FilePath& backing_filepath);
 
  private:
   // These private versions expect the kernel lock to already be held
   // before calling.
   EntryKernel* GetEntryById(const Id& id, ScopedKernelLock* const lock);
 
-  DirOpenResult OpenImpl(const FilePath& file_path, const PathString& name);
+  DirOpenResult OpenImpl(const FilePath& file_path, const std::string& name);
 
   struct DirectoryEventTraits {
     typedef DirectoryEvent EventType;
     static inline bool IsChannelShutdownEvent(const DirectoryEvent& event) {
       return DIRECTORY_DESTROYED == event;
     }
   };
  public:
   typedef EventChannel<DirectoryEventTraits, Lock> Channel;
   typedef EventChannel<DirectoryChangeEvent, Lock> ChangesChannel;
   typedef std::vector<int64> ChildHandles;
 
   // Returns the child meta handles for given parent id.
   void GetChildHandles(BaseTransaction*, const Id& parent_id,
-      const PathString& path_spec, ChildHandles* result);
+      const std::string& path_spec, ChildHandles* result);
   void GetChildHandles(BaseTransaction*, const Id& parent_id,
       ChildHandles* result);
   void GetChildHandlesImpl(BaseTransaction* trans, const Id& parent_id,
                            PathMatcher* matcher, ChildHandles* result);
 
   // Find the first or last child in the positional ordering under a parent,
   // and return its id.  Returns a root Id if parent has no children.
   Id GetFirstChildId(BaseTransaction* trans, const Id& parent_id);
   Id GetLastChildId(BaseTransaction* trans, const Id& parent_id);
 
@@ skipping 100 matching lines @@
   // the IdsIndex, but only non-deleted entries will be the
   // ParentIdChildIndex.
   // This index contains EntryKernels ordered by parent ID and metahandle.
   // It allows efficient lookup of the children of a given parent.
   typedef std::set<EntryKernel*, LessParentIdAndHandle> ParentIdChildIndex;
   typedef std::vector<int64> MetahandlesToPurge;
 
  private:
 
   struct Kernel {
-    Kernel(const FilePath& db_path, const PathString& name,
+    Kernel(const FilePath& db_path, const std::string& name,
            const KernelLoadInfo& info);
 
     ~Kernel();
 
     FilePath const db_path;
     // TODO(timsteele): audit use of the member and remove if possible
     volatile base::subtle::AtomicWord refcount;
     void AddRef();  // For convenience.
     void Release();
 
     // Implements ReadTransaction / WriteTransaction using a simple lock.
     Lock transaction_mutex;
 
     // The name of this directory, used as a key into open_files_;
-    PathString const name_;
+    std::string const name_;
 
     // Protects all members below.
     // The mutex effectively protects all the indices, but not the
     // entries themselves.  So once a pointer to an entry is pulled
     // from the index, the mutex can be unlocked and entry read or written.
     //
     // Never hold the mutex and do anything with the database or any
     // other buffered IO.  Violating this rule will result in deadlock.
     Lock mutex;
     MetahandlesIndex* metahandles_index;  // Entries indexed by metahandle
@@ skipping 121 matching lines @@
  protected:
   // Before an entry gets modified, we copy the original into a list
   // so that we can issue change notifications when the transaction
   // is done.
   OriginalEntries* const originals_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteTransaction);
 };
 
 bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
-int ComparePathNames(const PathString& a, const PathString& b);
+int ComparePathNames(const std::string& a, const std::string& b);
 
 // Exposed in header as this is used as a sqlite3 callback.
 int ComparePathNames16(void*, int a_bytes, const void* a, int b_bytes,
                        const void* b);
 
 int64 Now();
 
 class ExtendedAttribute {
  public:
   ExtendedAttribute(BaseTransaction* trans, GetByHandle,
                     const ExtendedAttributeKey& key);
   int64 metahandle() const { return i_->first.metahandle; }
-  const PathString& key() const { return i_->first.key; }
+  const std::string& key() const { return i_->first.key; }
   const Blob& value() const { return i_->second.value; }
   bool is_deleted() const { return i_->second.is_deleted; }
   bool good() const { return good_; }
   bool operator < (const ExtendedAttribute& x) const {
     return i_->first < x.i_->first;
   }
  protected:
   bool Init(BaseTransaction* trans,
             Directory::Kernel* const kernel,
             ScopedKernelLock* lock,
@@ skipping 20 matching lines @@
     i_->second.dirty = true;
     i_->second.is_deleted = true;
   }
 };
 
 // Get an extended attribute from an Entry by name. Returns a pointer
 // to a const Blob containing the attribute data, or NULL if there is
 // no attribute with the given name. The pointer is valid for the
 // duration of the Entry's transaction.
 const Blob* GetExtendedAttributeValue(const Entry& e,
-                                      const PathString& attribute_name);
+                                      const std::string& attribute_name);
 
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e);
 
 // This is not a reset.  It just sets the numeric fields which are not
 // initialized by the constructor to zero.
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 browser_sync::FastDump& operator <<
   (browser_sync::FastDump&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_