[Sync] Rename csync namespace to syncer

sync/engine/process_commit_response_command_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 "sync/engine/process_commit_response_command.h"
 
 #include <vector>
 
 #include "base/location.h"
 #include "base/stringprintf.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/sync_session.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/read_transaction.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/engine/syncer_command_test.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace csync {
+namespace syncer {
 
 using sessions::SyncSession;
 using std::string;
 using syncable::BASE_VERSION;
 using syncable::Entry;
 using syncable::IS_DIR;
 using syncable::IS_UNSYNCED;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::NON_UNIQUE_NAME;
@@ skipping 76 matching lines @@
   // Create a new unsynced item in the database, and synthesize a commit
   // record and a commit response for it in the syncer session.  If item_id
   // is a local ID, the item will be a create operation.  Otherwise, it
   // will be an edit.
   void CreateUnprocessedCommitResult(
       const Id& item_id,
       const Id& parent_id,
       const string& name,
       syncable::ModelType model_type,
       sessions::OrderedCommitSet *commit_set,
-      csync::ClientToServerMessage *commit,
-      csync::ClientToServerResponse *response) {
+      syncer::ClientToServerMessage *commit,
+      syncer::ClientToServerResponse *response) {
     bool is_folder = true;
     int64 metahandle = 0;
     CreateUnsyncedItem(item_id, parent_id, name, is_folder, model_type,
                        &metahandle);
 
     // ProcessCommitResponseCommand consumes commit_ids from the session
     // state, so we need to update that.  O(n^2) because it's a test.
     commit_set->AddCommitItem(metahandle, item_id, model_type);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
@@ skipping 50 matching lines @@
   TestIdFactory id_factory_;
  private:
   int64 next_old_revision_;
   int64 next_new_revision_;
   int64 next_server_position_;
   DISALLOW_COPY_AND_ASSIGN(ProcessCommitResponseCommandTest);
 };
 
 TEST_F(ProcessCommitResponseCommandTest, MultipleCommitIdProjections) {
   sessions::OrderedCommitSet commit_set(session()->routing_info());
-  csync::ClientToServerMessage request;
-  csync::ClientToServerResponse response;
+  syncer::ClientToServerMessage request;
+  syncer::ClientToServerResponse response;
 
   Id bookmark_folder_id = id_factory_.NewLocalId();
   Id bookmark_id1 = id_factory_.NewLocalId();
   Id bookmark_id2 = id_factory_.NewLocalId();
   Id pref_id1 = id_factory_.NewLocalId(), pref_id2 = id_factory_.NewLocalId();
   Id autofill_id1 = id_factory_.NewLocalId();
   Id autofill_id2 = id_factory_.NewLocalId();
   CreateUnprocessedCommitResult(bookmark_folder_id, id_factory_.root(),
                                 "A bookmark folder", syncable::BOOKMARKS,
                                 &commit_set, &request, &response);
@@ skipping 62 matching lines @@
 // In particular, the folder has 50 children, which alternate between being
 // new items and preexisting items.  This mixture of new and old is meant to
 // be a torture test of the code in ProcessCommitResponseCommand that changes
 // an item's ID from a local ID to a server-generated ID on the first commit.
 // We commit only the first 25 children in the sibling order, leaving the
 // second 25 children as unsynced items.  http://crbug.com/33081 describes
 // how this scenario used to fail, reversing the order for the second half
 // of the children.
 TEST_F(ProcessCommitResponseCommandTest, NewFolderCommitKeepsChildOrder) {
   sessions::OrderedCommitSet commit_set(session()->routing_info());
-  csync::ClientToServerMessage request;
-  csync::ClientToServerResponse response;
+  syncer::ClientToServerMessage request;
+  syncer::ClientToServerResponse response;
 
   // Create the parent folder, a new item whose ID will change on commit.
   Id folder_id = id_factory_.NewLocalId();
   CreateUnprocessedCommitResult(folder_id, id_factory_.root(), "A",
                                 syncable::BOOKMARKS,
                                 &commit_set, &request, &response);
 
   // Verify that the item is reachable.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 106 matching lines @@
 };
 INSTANTIATE_TEST_CASE_P(ProcessCommitResponse,
                         MixedResult,
                         testing::Range(0, 1 << TEST_PARAM_BIT_COUNT));
 
 // This test commits 2 items (one bookmark, one autofill) and validates what
 // happens to the extensions activity records.  Commits could fail or succeed,
 // depending on the test parameter.
 TEST_P(MixedResult, ExtensionActivity) {
   sessions::OrderedCommitSet commit_set(session()->routing_info());
-  csync::ClientToServerMessage request;
-  csync::ClientToServerResponse response;
+  syncer::ClientToServerMessage request;
+  syncer::ClientToServerResponse response;
 
   EXPECT_NE(routing_info().find(syncable::BOOKMARKS)->second,
             routing_info().find(syncable::AUTOFILL)->second)
       << "To not be lame, this test requires more than one active group.";
 
   // Bookmark item setup.
   CreateUnprocessedCommitResult(id_factory_.NewServerId(),
       id_factory_.root(), "Some bookmark", syncable::BOOKMARKS,
       &commit_set, &request, &response);
   if (ShouldFailBookmarkCommit())
@@ skipping 27 matching lines @@
     EXPECT_EQ("ABC", final_monitor_records["ABC"].extension_id);
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
-}  // namespace csync
+}  // namespace syncer