[Sync] Rename csync namespace to syncer

sync/syncable/directory_backing_store_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 269 matching lines @@
 
 // Returns a map from metahandle -> expected time (as a Time object).
 std::map<int64, base::Time> GetExpectedMetaTimes() {
   std::map<int64, base::Time> expected_meta_times;
   const std::map<int64, int64>& expected_meta_proto_times =
       GetExpectedMetaProtoTimes(INCLUDE_DELETED_ITEMS);
   for (std::map<int64, int64>::const_iterator it =
            expected_meta_proto_times.begin();
        it != expected_meta_proto_times.end(); ++it) {
     expected_meta_times[it->first] =
-        csync::ProtoTimeToTime(it->second);
+        syncer::ProtoTimeToTime(it->second);
   }
   return expected_meta_times;
 }
 
 // Extracts a map from metahandle -> time (in proto format) from the
 // given database.
 std::map<int64, int64> GetMetaProtoTimes(sql::Connection *db) {
   sql::Statement s(db->GetCachedStatement(
           SQL_FROM_HERE,
           "SELECT metahandle, mtime, server_mtime, ctime, server_ctime "
@@ skipping 19 matching lines @@
                                             const char* t2_expr,
                                             const base::Time& t1,
                                             const base::Time& t2) {
   if (t1 == t2)
     return ::testing::AssertionSuccess();
 
   return ::testing::AssertionFailure()
       << t1_expr << " and " << t2_expr
       << " (internal values: " << t1.ToInternalValue()
       << " and " << t2.ToInternalValue()
-      << ") (proto time: " << csync::TimeToProtoTime(t1)
-      << " and " << csync::TimeToProtoTime(t2)
+      << ") (proto time: " << syncer::TimeToProtoTime(t1)
+      << " and " << syncer::TimeToProtoTime(t2)
       << ") do not match";
 }
 
 // Expect that all time fields of the given entry kernel will be the
 // given time.
 void ExpectTime(const EntryKernel& entry_kernel,
                 const base::Time& expected_time) {
   EXPECT_PRED_FORMAT2(AssertTimesMatch,
                       expected_time, entry_kernel.ref(CTIME));
   EXPECT_PRED_FORMAT2(AssertTimesMatch,
@@ skipping 1810 matching lines @@
   const std::string& guid1 = TestDirectoryBackingStore::GenerateCacheGUID();
   const std::string& guid2 = TestDirectoryBackingStore::GenerateCacheGUID();
   EXPECT_EQ(24U, guid1.size());
   EXPECT_EQ(24U, guid2.size());
   // In theory this test can fail, but it won't before the universe
   // dies of heat death.
   EXPECT_NE(guid1, guid2);
 }
 
 }  // namespace syncable