Fix compiling of sync on linux.

chrome/browser/sync/syncable/directory_backing_store.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/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #ifdef OS_MACOSX
 #include <CoreFoundation/CoreFoundation.h>
-#elif defined(OS_LINUX)
-#include <glib.h>
 #endif
 
 #include <string>
 
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable_columns.h"
 #include "chrome/browser/sync/util/crypto_helpers.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 #include "chrome/browser/sync/util/query_helpers.h"
 #include "third_party/sqlite/preprocessed/sqlite3.h"
 
+// Sometimes threads contend on the DB lock itself, especially when one thread
+// is calling SaveChanges.  In the worst case scenario, the user can put his
+// laptop to sleep during db contention, and wake up the laptop days later, so
+// infinity seems like the best choice here.
+const int kDirectoryBackingStoreBusyTimeoutMs = std::numeric_limits<int>::max();
+
 // If sizeof(time_t) != sizeof(int32) we need to alter or expand the sqlite
 // datatype.
 COMPILE_ASSERT(sizeof(time_t) == sizeof(int32), time_t_is_not_int32);
 
 using std::string;
 
 namespace syncable {
 
 // This just has to be big enough to hold an UPDATE or INSERT statement that
 // modifies all the columns in the entry table.
 static const string::size_type kUpdateStatementBufferSize = 2048;
 
 // Increment this version whenever updating DB tables.
 static const int32 kCurrentDBVersion = 67;
 
+#if OS_WIN
 // TODO(sync): remove
 static void PathNameMatch16(sqlite3_context* context, int argc,
                             sqlite3_value** argv) {
   const PathString pathspec(reinterpret_cast<const PathChar*>
       (sqlite3_value_text16(argv[0])), sqlite3_value_bytes16(argv[0]) / 2);
 
   const void* name_text = sqlite3_value_text16(argv[1]);
   int name_bytes = sqlite3_value_bytes16(argv[1]);
   // If the text is null, we need to avoid the PathString constructor.
   if (name_text != NULL) {
     // Have to copy to append a terminating 0 anyway.
     const PathString name(reinterpret_cast<const PathChar*>
         (sqlite3_value_text16(argv[1])),
         sqlite3_value_bytes16(argv[1]) / 2);
     sqlite3_result_int(context, PathNameMatch(name, pathspec));
   } else {
     sqlite3_result_int(context, PathNameMatch(PathString(), pathspec));
   }
 }
 
 // Sqlite allows setting of the escape character in an ESCAPE clause and
 // this character is passed in as a third character to the like function.
 // See: http://www.sqlite.org/lang_expr.html
 static void PathNameMatch16WithEscape(sqlite3_context* context,
                                       int argc, sqlite3_value** argv) {
   // Never seen this called, but just in case.
   LOG(FATAL) << "PathNameMatch16WithEscape() not implemented";
 }
+#endif
 
 static void RegisterPathNameCollate(sqlite3* dbhandle) {
 #ifdef OS_WIN
   const int collate = SQLITE_UTF16;
 #else
   const int collate = SQLITE_UTF8;
 #endif
   CHECK(SQLITE_OK == sqlite3_create_collation(dbhandle, "PATHNAME", collate,
       NULL, &ComparePathNames16));
 }
@@ skipping 158 matching lines @@
   }
   query.push_back(')');
   return query;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DirectoryBackingStore implementation.
 
 DirectoryBackingStore::DirectoryBackingStore(const PathString& dir_name,
     const PathString& backing_filepath)
-    : dir_name_(dir_name), backing_filepath_(backing_filepath),
-      load_dbhandle_(NULL), save_dbhandle_(NULL) {
+    : load_dbhandle_(NULL),
+      save_dbhandle_(NULL),
+      dir_name_(dir_name),
+      backing_filepath_(backing_filepath) {
 }
 
 DirectoryBackingStore::~DirectoryBackingStore() {
   if (NULL != load_dbhandle_) {
     sqlite3_close(load_dbhandle_);
     load_dbhandle_ = NULL;
   }
   if (NULL != save_dbhandle_) {
     sqlite3_close(save_dbhandle_);
     save_dbhandle_ = NULL;
@@ skipping 369 matching lines @@
            "?)",   // cache_guid
            dir_name_,                  // id
            dir_name_,                  // name
            false,                        // initial_sync_ended
            "",                           // store_birthday
            SYNC_ENGINE_VERSION_STRING,   // db_create_version
            static_cast<int32>(time(0)),  // db_create_time
            GenerateCacheGUID());         // cache_guid
   // Create the big metas table.
   string query = "CREATE TABLE metas " + ComposeCreateTableColumnSpecs
-      (g_metas_columns, g_metas_columns + ARRAYSIZE(g_metas_columns));
+      (g_metas_columns, g_metas_columns + arraysize(g_metas_columns));
   result = SQLITE_DONE != result ? result : Exec(load_dbhandle_, query.c_str());
   // Insert the entry for the root into the metas table.
   const int64 now = Now();
   result = SQLITE_DONE != result ? result :
     Exec(load_dbhandle_, "INSERT INTO metas "
          "( id, metahandle, is_dir, ctime, mtime) "
          "VALUES ( \"r\", 1, 1, ?, ?)",
          now, now);
   result = SQLITE_DONE != result ? result : CreateExtendedAttributeTable();
   return result;
 }
 
 sqlite3* DirectoryBackingStore::LazyGetSaveHandle() {
   if (!save_dbhandle_ && !OpenAndConfigureHandleHelper(&save_dbhandle_)) {
     DCHECK(FALSE) << "Unable to open handle for saving";
     return NULL;
   }
   return save_dbhandle_;
 }
 
 }  // namespace syncable