Fix compiling of sync on linux.

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>
+#ifdef OS_LINUX
+#include <sys/time.h>
+#endif
 #include <sys/types.h>
 #include <time.h>
 #ifdef OS_MACOSX
 #include <CoreFoundation/CoreFoundation.h>
-#elif defined(OS_LINUX)
-#include <glib.h>
 #elif defined(OS_WIN)
 #include <shlwapi.h>  // for PathMatchSpec
 #endif
 
 #include <algorithm>
 #include <functional>
 #include <iomanip>
 #include <iterator>
 #include <set>
 #include <string>
@@ skipping 69 matching lines @@
                        const void* b) {
 #ifdef 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)
-// misnomer for Linux. These are already utf8 bit strings.
-  gchar *case_folded_a;
-  gchar *case_folded_b;
-  GError *err = NULL;
-  case_folded_a = g_utf8_casefold(reinterpret_cast<const gchar*>(a), a_bytes);
-  CHECK(case_folded_a != NULL) << "g_utf8_casefold failed";
-  case_folded_b = g_utf8_casefold(reinterpret_cast<const gchar*>(b), b_bytes);
-  CHECK(case_folded_b != NULL) << "g_utf8_casefold failed";
-  gint result = g_utf8_collate(case_folded_a, case_folded_b);
-  g_free(case_folded_a);
-  g_free(case_folded_b);
-  if (result < 0) return -1;
-  if (result > 0) return 1;
-  return 0;
+  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);
@@ skipping 74 matching lines @@
   ids_index(new Directory::IdsIndex),
   parent_id_and_names_index(new Directory::ParentIdAndNamesIndex),
   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),
-  next_id(info.kernel_info.next_id),
   cache_guid_(info.cache_guid),
-  next_metahandle(info.max_metahandle + 1) {
+  next_metahandle(info.max_metahandle + 1),
+  next_id(info.kernel_info.next_id) {
   info_status_ = Directory::KERNEL_SHARE_INFO_VALID;
   CHECK(0 == pthread_mutex_init(&mutex, NULL));
   CHECK(0 == pthread_key_create(&thread_node_key, &DestroyThreadNodeKey));
 }
 
 inline void DeleteEntry(EntryKernel* kernel) {
   delete kernel;
 }
 
 void Directory::Kernel::AddRef() {
@@ skipping 578 matching lines @@
     MetahandlesIndex::iterator found =
         kernel_->metahandles_index->find(&kernel_->needle);
     EntryKernel* entry = (found == kernel_->metahandles_index->end() ?
                           NULL : *found);
     if (entry && SafeToPurgeFromMemory(entry)) {
       // We now drop deleted metahandles that are up to date on both the client
       // and the server.
       size_t num_erased = 0;
       kernel_->flushed_metahandles_.Push(entry->ref(META_HANDLE));
       num_erased = kernel_->ids_index->erase(entry);
-      DCHECK_EQ(1, num_erased);
+      DCHECK(1 == num_erased);
       num_erased = kernel_->metahandles_index->erase(entry);
-      DCHECK_EQ(1, num_erased);
+      DCHECK(1 == num_erased);
       delete entry;
     }
   }
 
   ExtendedAttributes::const_iterator i = snapshot.dirty_xattrs.begin();
   while (i != snapshot.dirty_xattrs.end()) {
     ExtendedAttributeKey key(i->first.metahandle, i->first.key);
     ExtendedAttributes::iterator found =
         kernel_->extended_attributes->find(key);
     if (found == kernel_->extended_attributes->end() ||
@@ skipping 1168 matching lines @@
   return dump;
 }
 
 std::ostream& operator<<(std::ostream& s, const syncable::ThreadNode& node) {
   s << "thread id: " << std::hex << node.id << "\n"
     << "file: " << node.file << "\n"
     << "line: " << std::dec << node.line << "\n"
     << "wait_started: " << node.wait_started.ToInternalValue();
   return s;
 }