String cleanup in sync code

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>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
+#include "base/file_path.h"
 #include "base/lock.h"
 #include "base/time.h"
 #include "chrome/browser/sync/syncable/blob.h"
 #include "chrome/browser/sync/syncable/dir_open_result.h"
 #include "chrome/browser/sync/syncable/directory_event.h"
 #include "chrome/browser/sync/syncable/path_name_cmp.h"
 #include "chrome/browser/sync/syncable/syncable_id.h"
-#include "chrome/browser/sync/util/compat_file.h"
 #include "chrome/browser/sync/util/dbgq.h"
 #include "chrome/browser/sync/util/event_sys.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 #include "chrome/browser/sync/util/row_iterator.h"
 #include "chrome/browser/sync/util/sync_types.h"
 
 struct PurgeInfo;
 
 namespace sync_api {
 class ReadTransaction;
@@ skipping 276 matching lines @@
       non_unique_value_ = value_;
     }
     // TODO(ncarter): Handle server's other requirement: truncation to 256
     // bytes in Unicode NFC.
   }
 
   const PathString& value() const { return value_; }
   PathString& value() { return value_; }
   const PathString& non_unique_value() const { return non_unique_value_; }
   PathString& non_unique_value() { return non_unique_value_; }
+  void set_non_unique_value(const PathString& value) {
+    non_unique_value_ = value;
+  }
 
   inline bool operator==(const SyncName& right_hand_side) const {
     return value_ == right_hand_side.value_ &&
         non_unique_value_ == right_hand_side.non_unique_value_;
   }
   inline bool operator!=(const SyncName& right_hand_side) const {
     return !(*this == right_hand_side);
   }
  private:
   PathString value_;
@@ skipping 547 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 PathString& file_path, const PathString& name);
+  DirOpenResult Open(const FilePath& file_path, const PathString& name);
 
   void Close();
 
   int64 NextMetahandle();
   // Always returns a negative id.  Positive client ids are generated
   // by the server only.
   Id NextId();
 
-  PathString file_path() const { return kernel_->db_path; }
+  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);
@@ skipping 22 matching lines @@
   bool ReindexParentIdAndName(EntryKernel* const entry, const Id& new_parent_id,
                               const PathString& new_name);
   // These don't do the semantic checking that the redirector needs.
   // The semantic checking is implemented higher up.
   bool Undelete(EntryKernel* const entry);
   bool Delete(EntryKernel* const entry);
 
   // Overridden by tests.
   virtual DirectoryBackingStore* CreateBackingStore(
       const PathString& dir_name,
-      const PathString& backing_filepath);
+      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);
   EntryKernel* GetChildWithName(const Id& parent_id,
                                 const PathString& name,
                                 ScopedKernelLock* const lock);
   EntryKernel* GetChildWithNameImpl(const Id& parent_id,
                                     const PathString& name,
                                     ScopedKernelLock* const lock);
 
-  DirOpenResult OpenImpl(const PathString& file_path, const PathString& name);
+  DirOpenResult OpenImpl(const FilePath& file_path, const PathString& 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;
@@ skipping 114 matching lines @@
   // All entries in memory must be in both the MetahandlesIndex and
   // the IdsIndex, but only non-deleted entries will be the
   // ParentIdAndNamesIndex, because there can be multiple deleted
   // entries with the same parent id and name.
   typedef std::set<EntryKernel*, LessParentIdAndNames> ParentIdAndNamesIndex;
   typedef std::vector<int64> MetahandlesToPurge;
 
  private:
 
   struct Kernel {
-    Kernel(const PathString& db_path, const PathString& name,
+    Kernel(const FilePath& db_path, const PathString& name,
            const KernelLoadInfo& info);
 
     ~Kernel();
 
-    PathString const db_path;
+    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_;
@@ skipping 142 matching lines @@
 
 // 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();
 
 // Does wildcard processing.
 BOOL PathNameMatch(const PathString& pathname, const PathString& pathspec);
 
-PathString GetFullPath(BaseTransaction* trans, const Entry& e);
-
-inline void ReverseAppend(const PathString& s, PathString* target) {
-  target->append(s.rbegin(), s.rend());
-}
-
 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 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 {
@@ skipping 43 matching lines @@
 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_