String cleanup in sync code

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)
 #include <sys/time.h>
 #endif
 #include <sys/types.h>
 #include <time.h>
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #elif defined(OS_WIN)
 #include <shlwapi.h>  // for PathMatchSpec
 #endif
 
 #include <algorithm>
 #include <functional>
 #include <iomanip>
 #include <iterator>
 #include <set>
 #include <string>
 
 #include "base/hash_tables.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/perftimer.h"
 #include "base/scoped_ptr.h"
+#include "base/string_util.h"
 #include "base/time.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable_changes_version.h"
 #include "chrome/browser/sync/syncable/syncable_columns.h"
-#include "chrome/browser/sync/util/character_set_converters.h"
-#include "chrome/browser/sync/util/compat_file.h"
 #include "chrome/browser/sync/util/crypto_helpers.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "chrome/browser/sync/util/fast_dump.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 
 namespace {
 enum InvariantCheckLevel {
   OFF = 0,
   VERIFY_IN_MEMORY = 1,
   FULL_DB_VERIFICATION = 2
@@ skipping 30 matching lines @@
 #error NEED OS SPECIFIC Now() implementation
 #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Compare functions and hashes for the indices.
 
 // Callback for sqlite3
 int ComparePathNames16(void*, int a_bytes, const void* a, int b_bytes,
                        const void* b) {
-#if defined(OS_WIN)
-  DCHECK_EQ(0, a_bytes % 2);
-  DCHECK_EQ(0, b_bytes % 2);
-  int result = CompareString(LOCALE_INVARIANT, NORM_IGNORECASE,
-    static_cast<const PathChar*>(a), a_bytes / 2,
-    static_cast<const PathChar*>(b), b_bytes / 2);
-  CHECK(0 != result) << "Error comparing strings: " << GetLastError();
-  return result - 2;  // Convert to -1, 0, 1
-#elif defined(OS_LINUX)
   int result = base::strncasecmp(reinterpret_cast<const char *>(a),
                                  reinterpret_cast<const char *>(b),
                                  std::min(a_bytes, b_bytes));
   if (result != 0) {
     return result;
   } else {
     return a_bytes > b_bytes ? 1 : b_bytes > a_bytes ? -1 : 0;
   }
-#elif defined(OS_MACOSX)
-  CFStringRef a_str;
-  CFStringRef b_str;
-  a_str = CFStringCreateWithBytes(NULL, reinterpret_cast<const UInt8*>(a),
-                                  a_bytes, kCFStringEncodingUTF8, FALSE);
-  b_str = CFStringCreateWithBytes(NULL, reinterpret_cast<const UInt8*>(b),
-                                  b_bytes, kCFStringEncodingUTF8, FALSE);
-  CFComparisonResult res;
-  res = CFStringCompare(a_str, b_str, kCFCompareCaseInsensitive);
-  CFRelease(a_str);
-  CFRelease(b_str);
-  return res;
-#else
-#error no ComparePathNames16() for your OS
-#endif
 }
 
 template <Int64Field field_index>
 class SameField {
  public:
   inline bool operator()(const syncable::EntryKernel* a,
                          const syncable::EntryKernel* b) const {
     return a->ref(field_index) == b->ref(field_index);
   }
 };
@@ skipping 35 matching lines @@
       kernel->ref(NAME) : kernel->ref(UNSANITIZED_NAME);
   return Name(kernel->ref(NAME), sync_name_ref, kernel->ref(NON_UNIQUE_NAME));
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Directory
 
 static const DirectoryChangeEvent kShutdownChangesEvent =
     { DirectoryChangeEvent::SHUTDOWN, 0, 0 };
 
-Directory::Kernel::Kernel(const PathString& db_path,
+Directory::Kernel::Kernel(const FilePath& db_path,
                           const PathString& name,
                           const KernelLoadInfo& info)
 : db_path(db_path),
   refcount(1),
   name_(name),
   metahandles_index(new Directory::MetahandlesIndex),
   ids_index(new Directory::IdsIndex),
   parent_id_and_names_index(new Directory::ParentIdAndNamesIndex),
   extended_attributes(new ExtendedAttributes),
   unapplied_update_metahandles(new MetahandleSet),
@@ skipping 49 matching lines @@
 
   // PathMatchSpec strips spaces from the start of pathspec, so we compare those
   // ourselves.
   const PathChar* pathname_ptr = pathname.c_str();
   const PathChar* pathspec_ptr = pathspec.c_str();
 
   while (*pathname_ptr == ' ' && *pathspec_ptr == ' ')
      ++pathname_ptr, ++pathspec_ptr;
 
   // If we have more inital spaces in the pathspec than in the pathname then the
-  // result from PathMatchSpec will be erronous.
+  // result from PathMatchSpec will be erroneous.
   if (*pathspec_ptr == ' ')
     return FALSE;
 
   // PathMatchSpec also gets "confused" when there are ';' characters in name or
   // in spec. So, if we match (f.i.) ";" with ";" PathMatchSpec will return
   // FALSE (which is wrong). Luckily for us, we can easily fix this by
   // substituting ';' with ':' which is illegal character in file name and
   // we're not going to see it there. With ':' in path name and spec
   // PathMatchSpec works fine.
-  if ((NULL == wcschr(pathname_ptr, L';')) &&
-      (NULL == wcschr(pathspec_ptr, L';'))) {
+  if ((NULL == strchr(pathname_ptr, ';')) &&
+      (NULL == strchr(pathspec_ptr, ';'))) {
     // No ';' in file name and in spec. Just pass it as it is.
-    return ::PathMatchSpec(pathname_ptr, pathspec_ptr);
+    return ::PathMatchSpecA(pathname_ptr, pathspec_ptr);
   }
 
   // We need to subst ';' with ':' in both, name and spec.
   PathString name_subst(pathname_ptr);
   PathString spec_subst(pathspec_ptr);
 
   PathString::size_type index = name_subst.find(L';');
   while (PathString::npos != index) {
-    name_subst[index] = L':';
-    index = name_subst.find(L';', index + 1);
+    name_subst[index] = ':';
+    index = name_subst.find(';', index + 1);
   }
 
   index = spec_subst.find(L';');
   while (PathString::npos != index) {
-    spec_subst[index] = L':';
-    index = spec_subst.find(L';', index + 1);
+    spec_subst[index] = ':';
+    index = spec_subst.find(';', index + 1);
   }
 
-  return ::PathMatchSpec(name_subst.c_str(), spec_subst.c_str());
+  return ::PathMatchSpecA(name_subst.c_str(), spec_subst.c_str());
 #else
   return 0 == ComparePathNames(pathname, pathspec);
 #endif
 }
 
-DirOpenResult Directory::Open(const PathString& file_path,
+DirOpenResult Directory::Open(const FilePath& file_path,
                               const PathString& 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_and_names_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 PathString& backing_filepath) {
+    const PathString& dir_name, const FilePath& backing_filepath) {
   return new DirectoryBackingStore(dir_name, backing_filepath);
 }
 
-DirOpenResult Directory::OpenImpl(const PathString& file_path,
+DirOpenResult Directory::OpenImpl(const FilePath& file_path,
                                   const PathString& name) {
   DCHECK_EQ(static_cast<DirectoryBackingStore*>(NULL), store_);
-  const PathString db_path = ::GetFullPath(file_path);
+  FilePath db_path(file_path);
+  file_util::AbsolutePath(&db_path);
   store_ = CreateBackingStore(name, db_path);
 
   KernelLoadInfo info;
-  // Temporary indicies before kernel_ initialized in case Load fails. We 0(1)
+  // Temporary indices before kernel_ initialized in case Load fails. We 0(1)
   // swap these later.
   MetahandlesIndex metas_bucket;
   ExtendedAttributes xattrs_bucket;
   DirOpenResult result = store_->Load(&metas_bucket, &xattrs_bucket, &info);
   if (OPENED != result)
     return result;
 
   kernel_ = new Kernel(db_path, name, info);
   kernel_->metahandles_index->swap(metas_bucket);
   kernel_->extended_attributes->swap(xattrs_bucket);
@@ skipping 166 matching lines @@
     return index->lower_bound(&needle_);
   }
   virtual Index::iterator upper_bound(Index* index) {
     needle_.ref(PARENT_ID) = parent_id_;
     needle_.ref(NAME) = pathspec_;
     return index->upper_bound(&needle_);
   }
   const PathString pathspec_;
 };
 
-// Matches a pathspec with wildcards.
-struct PartialPathMatcher : public PathMatcher {
-  PartialPathMatcher(const PathString& pathspec,
-                     PathString::size_type wildcard, const Id& parent_id)
-    : PathMatcher(parent_id), pathspec_(pathspec) {
-    if (0 == wildcard)
-      return;
-    lesser_.assign(pathspec_.data(), wildcard);
-    greater_.assign(pathspec_.data(), wildcard);
-    // Increment the last letter of greater so we can then less than
-    // compare to it.
-    PathString::size_type i = greater_.size() - 1;
-    do {
-    if (greater_[i] == std::numeric_limits<PathString::value_type>::max()) {
-        greater_.resize(i);  // Try the preceding character.
-        if (0 == i--)
-          break;
-      } else {
-        greater_[i] += 1;
-      }
-      // Yes, there are cases where incrementing a character
-      // actually decreases its position in the sort.  Example: 9 -> :
-    } while (ComparePathNames(lesser_, greater_) >= 0);
-  }
-
-  virtual MatchType PathMatches(const PathString& path) {
-    return PathNameMatch(path, pathspec_) ? MATCH : NO_MATCH;
-  }
-
-  virtual Index::iterator lower_bound(Index* index) {
-    needle_.ref(PARENT_ID) = parent_id_;
-    needle_.ref(NAME) = lesser_;
-    return index->lower_bound(&needle_);
-  }
-  virtual Index::iterator upper_bound(Index* index) {
-    if (greater_.empty()) {
-      needle_.ref(PARENT_ID) = parent_id_;
-      needle_.ref(NAME).clear();
-      Index::iterator i = index->upper_bound(&needle_),
-        end = index->end();
-      while (i != end && (*i)->ref(PARENT_ID) == parent_id_)
-        ++i;
-      return i;
-    } else {
-      needle_.ref(PARENT_ID) = parent_id_;
-      needle_.ref(NAME) = greater_;
-      return index->lower_bound(&needle_);
-    }
-  }
-
-  const PathString pathspec_;
-  PathString lesser_;
-  PathString greater_;
-};
-
-
 void Directory::GetChildHandles(BaseTransaction* trans, const Id& parent_id,
                                 Directory::ChildHandles* result) {
   AllPathsMatcher matcher(parent_id);
   return GetChildHandlesImpl(trans, parent_id, &matcher, result);
 }
 
 void Directory::GetChildHandlesImpl(BaseTransaction* trans, const Id& parent_id,
                                     PathMatcher* matcher,
                                     Directory::ChildHandles* result) {
   CHECK(this == trans->directory());
@@ skipping 1076 matching lines @@
   return true;
 }
 
 // returns -1 if s contains any non [0-9] characters
 static int PathStringToInteger(PathString s) {
   PathString::const_iterator i = s.begin();
   for (; i != s.end(); ++i) {
     if (PathString::npos == PathString(PSTR("0123456789")).find(*i))
       return -1;
   }
-  return
-#if !PATHSTRING_IS_STD_STRING
-  _wtoi
-#else
-  atoi
-#endif
-  (s.c_str());
-}
-
-static PathString IntegerToPathString(int i) {
-  const size_t kBufSize = 25;
-  PathChar buf[kBufSize];
-#if !PATHSTRING_IS_STD_STRING
-  const int radix = 10;
-  _itow(i, buf, radix);
-#else
-  snprintf(buf, kBufSize, "%d", i);
-#endif
-  return buf;
+  return atoi(s.c_str());
 }
 
 // appends ~1 to the end of 's' unless there is already ~#, in which case
 // it just increments the number
 static PathString FixBasenameInCollision(const PathString s) {
   PathString::size_type last_tilde = s.find_last_of(PSTR('~'));
   if (PathString::npos == last_tilde) return s + PSTR("~1");
   if (s.size() == (last_tilde + 1)) return s + PSTR("1");
   // we have ~, but not necessarily ~# (for some number >= 0). check for that
   int n;
   if ((n = PathStringToInteger(s.substr(last_tilde + 1))) != -1) {
     n++;
     PathString pre_number = s.substr(0, last_tilde + 1);
-    return pre_number + IntegerToPathString(n);
+    return pre_number + IntToString(n);
   } else {
     // we have a ~, but not a number following it, so we'll add another
     // ~ and this time, a number
     return s + PSTR("~1");
   }
 }
 
 void DBName::MakeNoncollidingForEntry(BaseTransaction* trans,
                                       const Id& parent_id,
                                       Entry* e) {
@@ skipping 13 matching lines @@
     if (!same_path_entry.good() || (e && same_path_entry.Get(ID) == e->Get(ID)))
       break;
     // There was a collision, so fix the name.
     basename = FixBasenameInCollision(basename);
   }
   // Set our value to the new value.  This invalidates desired_name.
   PathString new_value = basename + dotextension;
   swap(new_value);
 }
 
-PathString GetFullPath(BaseTransaction* trans, const Entry& e) {
-  PathString result;
-#if defined(COMPILER_MSVC)
-  result.reserve(MAX_PATH);
-#endif
-  ReverseAppend(e.Get(NAME), &result);
-  Id id = e.Get(PARENT_ID);
-  while (!id.IsRoot()) {
-    result.push_back(kPathSeparator[0]);
-    Entry ancestor(trans, GET_BY_ID, id);
-    if (!ancestor.good()) {
-      // This can happen if the parent folder got deleted before the entry.
-      LOG(WARNING) << "Cannot get full path of " << e
-                   << "\nbecause an ancestor folder has been deleted.";
-      result.clear();
-      return result;
-    }
-    ReverseAppend(ancestor.Get(NAME), &result);
-    id = ancestor.Get(PARENT_ID);
-  }
-  result.push_back(kPathSeparator[0]);
-  reverse(result.begin(), result.end());
-  return result;
-}
-
 const Blob* GetExtendedAttributeValue(const Entry& e,
                                       const PathString& 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.
@@ skipping 19 matching lines @@
 }
 
 inline FastDump& operator<<(FastDump& dump, const DumpColon&) {
   dump.out_->sputn(": ", 2);
   return dump;
 }
 
 std::ostream& operator<<(std::ostream& stream, const syncable::Entry& entry) {
   // Using ostreams directly here is dreadfully slow, because a mutex is
   // acquired for every <<.  Users noticed it spiking CPU.
-  using browser_sync::ToUTF8;
   using syncable::BitField;
   using syncable::BitTemp;
   using syncable::BlobField;
   using syncable::EntryKernel;
   using syncable::g_metas_columns;
   using syncable::IdField;
   using syncable::Int64Field;
   using syncable::StringField;
   using syncable::BEGIN_FIELDS;
   using syncable::BIT_FIELDS_END;
@@ skipping 14 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) {
-    ToUTF8 field(kernel->ref(static_cast<StringField>(i)));
-    s << g_metas_columns[i].name << colon << field.get_string() << separator;
+    const PathString& 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;
 }