[Sync] Rename csync namespace to syncer

sync/syncable/directory_backing_store.cc

 // Copyright (c) 2012 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 "sync/syncable/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #include <limits>
 
@@ skipping 32 matching lines @@
 // updating.  Returns the number of args bound.
 void BindFields(const EntryKernel& entry,
                 sql::Statement* statement) {
   int index = 0;
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     statement->BindInt64(index++, entry.ref(static_cast<Int64Field>(i)));
   }
   for ( ; i < TIME_FIELDS_END; ++i) {
     statement->BindInt64(index++,
-                         csync::TimeToProtoTime(
+                         syncer::TimeToProtoTime(
                              entry.ref(static_cast<TimeField>(i))));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     statement->BindString(index++, entry.ref(static_cast<IdField>(i)).s_);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     statement->BindInt(index++, entry.ref(static_cast<BitField>(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     statement->BindString(index++, entry.ref(static_cast<StringField>(i)));
   }
   std::string temp;
   for ( ; i < PROTO_FIELDS_END; ++i) {
     entry.ref(static_cast<ProtoField>(i)).SerializeToString(&temp);
     statement->BindBlob(index++, temp.data(), temp.length());
   }
 }
 
 // The caller owns the returned EntryKernel*.  Assumes the statement currently
 // points to a valid row in the metas table.
 EntryKernel* UnpackEntry(sql::Statement* statement) {
   EntryKernel* kernel = new EntryKernel();
   DCHECK_EQ(statement->ColumnCount(), static_cast<int>(FIELD_COUNT));
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     kernel->put(static_cast<Int64Field>(i), statement->ColumnInt64(i));
   }
   for ( ; i < TIME_FIELDS_END; ++i) {
     kernel->put(static_cast<TimeField>(i),
-                csync::ProtoTimeToTime(statement->ColumnInt64(i)));
+                syncer::ProtoTimeToTime(statement->ColumnInt64(i)));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     kernel->mutable_ref(static_cast<IdField>(i)).s_ =
         statement->ColumnString(i);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     kernel->put(static_cast<BitField>(i), (0 != statement->ColumnInt(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     kernel->put(static_cast<StringField>(i),
@@ skipping 895 matching lines @@
 
   if (!CreateModelsTable())
     return false;
 
   // Create the big metas table.
   if (!CreateMetasTable(false))
     return false;
 
   {
     // Insert the entry for the root into the metas table.
-    const int64 now = csync::TimeToProtoTime(base::Time::Now());
+    const int64 now = syncer::TimeToProtoTime(base::Time::Now());
     sql::Statement s(db_->GetUniqueStatement(
             "INSERT INTO metas "
             "( id, metahandle, is_dir, ctime, mtime) "
             "VALUES ( \"r\", 1, 1, ?, ?)"));
     s.BindInt64(0, now);
     s.BindInt64(1, now);
 
     if (!s.Run())
       return false;
   }
@@ skipping 66 matching lines @@
       "name TEXT, "
       "store_birthday TEXT, "
       "db_create_version TEXT, "
       "db_create_time INT, "
       "next_id INT default -2, "
       "cache_guid TEXT )");
   return db_->Execute(query.c_str());
 }
 
 }  // namespace syncable