[Sync] Move sync/{internal_api,syncable} into syncer namespace

sync/test/engine/mock_connection_manager.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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "sync/test/engine/mock_connection_manager.h"
 
 #include <map>
 
 #include "base/location.h"
 #include "base/stringprintf.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using syncer::HttpResponse;
-using syncer::ServerConnectionManager;
-using syncer::ServerConnectionEventListener;
-using syncer::ServerConnectionEvent;
-using syncer::SyncerProtoUtil;
-using syncer::TestIdFactory;
 using std::map;
 using std::string;
-using sync_pb::ClientToServerMessage;
-using sync_pb::ClientToServerResponse;
 using sync_pb::CommitMessage;
 using sync_pb::CommitResponse;
-using sync_pb::CommitResponse_EntryResponse;
 using sync_pb::GetUpdatesMessage;
 using sync_pb::SyncEnums;
-using sync_pb::SyncEntity;
+
+namespace syncer {
+
 using syncable::FIRST_REAL_MODEL_TYPE;
 using syncable::MODEL_TYPE_COUNT;
 using syncable::ModelType;
 using syncable::WriteTransaction;
 
 static char kValidAuthToken[] = "AuthToken";
 
 MockConnectionManager::MockConnectionManager(syncable::Directory* directory)
     : ServerConnectionManager("unused", 0, false),
       server_reachable_(true),
@@ skipping 152 matching lines @@
   } else {
     entity->set_folder(is_folder);
     entity->mutable_specifics()->mutable_bookmark();
     if (!is_folder) {
       entity->mutable_specifics()->mutable_bookmark()->
           set_url("http://google.com");
     }
   }
 }
 
-SyncEntity* MockConnectionManager::AddUpdateDirectory(int id,
-                                                      int parent_id,
-                                                      string name,
-                                                      int64 version,
-                                                      int64 sync_ts) {
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
+    int id,
+    int parent_id,
+    string name,
+    int64 version,
+    int64 sync_ts) {
   return AddUpdateDirectory(TestIdFactory::FromNumber(id),
                             TestIdFactory::FromNumber(parent_id),
                             name,
                             version,
                             sync_ts);
 }
 
 sync_pb::ClientCommand* MockConnectionManager::GetNextClientCommand() {
   if (!client_command_.get())
     client_command_.reset(new sync_pb::ClientCommand());
   return client_command_.get();
 }
 
-SyncEntity* MockConnectionManager::AddUpdateBookmark(int id, int parent_id,
-                                                     string name, int64 version,
-                                                     int64 sync_ts) {
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
+    int id, int parent_id,
+    string name, int64 version,
+    int64 sync_ts) {
   return AddUpdateBookmark(TestIdFactory::FromNumber(id),
                            TestIdFactory::FromNumber(parent_id),
                            name,
                            version,
                            sync_ts);
 }
 
-SyncEntity* MockConnectionManager::AddUpdateSpecifics(
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
     int id, int parent_id, string name, int64 version, int64 sync_ts,
     bool is_dir, int64 position, const sync_pb::EntitySpecifics& specifics) {
-  SyncEntity* ent = AddUpdateMeta(
+  sync_pb::SyncEntity* ent = AddUpdateMeta(
       TestIdFactory::FromNumber(id).GetServerId(),
       TestIdFactory::FromNumber(parent_id).GetServerId(),
       name, version, sync_ts);
   ent->set_position_in_parent(position);
   ent->mutable_specifics()->CopyFrom(specifics);
   ent->set_folder(is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::SetNigori(
     int id, int64 version,int64 sync_ts,
     const sync_pb::EntitySpecifics& specifics) {
-  SyncEntity* ent = GetUpdateResponse()->add_entries();
+  sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(TestIdFactory::FromNumber(id).GetServerId());
   ent->set_parent_id_string(TestIdFactory::FromNumber(0).GetServerId());
   ent->set_server_defined_unique_tag(syncable::ModelTypeToRootTag(
       syncable::NIGORI));
   ent->set_name("Nigori");
   ent->set_non_unique_name("Nigori");
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(0);
   ent->set_folder(false);
   ent->mutable_specifics()->CopyFrom(specifics);
   return ent;
 }
 
-SyncEntity* MockConnectionManager::AddUpdateFull(string id, string parent_id,
-                                                 string name, int64 version,
-                                                 int64 sync_ts, bool is_dir) {
-  SyncEntity* ent = AddUpdateMeta(id, parent_id, name, version, sync_ts);
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateFull(
+    string id, string parent_id,
+    string name, int64 version,
+    int64 sync_ts, bool is_dir) {
+  sync_pb::SyncEntity* ent =
+      AddUpdateMeta(id, parent_id, name, version, sync_ts);
   AddDefaultBookmarkData(ent, is_dir);
   return ent;
 }
 
-SyncEntity* MockConnectionManager::AddUpdateMeta(string id, string parent_id,
-                                                 string name, int64 version,
-                                                 int64 sync_ts) {
-  SyncEntity* ent = GetUpdateResponse()->add_entries();
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateMeta(
+    string id, string parent_id,
+    string name, int64 version,
+    int64 sync_ts) {
+  sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(id);
   ent->set_parent_id_string(parent_id);
   ent->set_non_unique_name(name);
   ent->set_name(name);
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(GeneratePositionInParent());
   return ent;
 }
 
-SyncEntity* MockConnectionManager::AddUpdateDirectory(string id,
-                                                      string parent_id,
-                                                      string name,
-                                                      int64 version,
-                                                      int64 sync_ts) {
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
+    string id,
+    string parent_id,
+    string name,
+    int64 version,
+    int64 sync_ts) {
   return AddUpdateFull(id, parent_id, name, version, sync_ts, true);
 }
 
-SyncEntity* MockConnectionManager::AddUpdateBookmark(string id,
-                                                     string parent_id,
-                                                     string name, int64 version,
-                                                     int64 sync_ts) {
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
+    string id,
+    string parent_id,
+    string name, int64 version,
+    int64 sync_ts) {
   return AddUpdateFull(id, parent_id, name, version, sync_ts, false);
 }
 
-SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
   EXPECT_EQ(1, last_sent_commit().entries_size());
   EXPECT_EQ(1, last_commit_response().entryresponse_size());
   EXPECT_EQ(CommitResponse::SUCCESS,
       last_commit_response().entryresponse(0).response_type());
 
   if (last_sent_commit().entries(0).deleted()) {
     AddUpdateTombstone(syncable::Id::CreateFromServerId(
         last_sent_commit().entries(0).id_string()));
   } else {
-    SyncEntity* ent = GetUpdateResponse()->add_entries();
+    sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
     ent->CopyFrom(last_sent_commit().entries(0));
     ent->clear_insert_after_item_id();
     ent->clear_old_parent_id();
     ent->set_position_in_parent(
         last_commit_response().entryresponse(0).position_in_parent());
     ent->set_version(
         last_commit_response().entryresponse(0).version());
     ent->set_id_string(
         last_commit_response().entryresponse(0).id_string());
     // Tests don't currently care about the following:
     // originator_cache_guid, originator_client_item_id, parent_id_string,
     // name, non_unique_name.
   }
   return GetMutableLastUpdate();
 }
 
 void MockConnectionManager::AddUpdateTombstone(const syncable::Id& id) {
   // Tombstones have only the ID set and dummy values for the required fields.
-  SyncEntity* ent = GetUpdateResponse()->add_entries();
+  sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(id.GetServerId());
   ent->set_version(0);
   ent->set_name("");
   ent->set_deleted(true);
 }
 
 void MockConnectionManager::SetLastUpdateDeleted() {
   // Tombstones have only the ID set.  Wipe anything else.
   string id_string = GetMutableLastUpdate()->id_string();
   GetUpdateResponse()->mutable_entries()->RemoveLast();
@@ skipping 31 matching lines @@
         GetUpdateResponse()->add_new_progress_marker();
     new_marker->set_data_type_id(-1);  // Invalid -- clients shouldn't see.
     new_marker->set_token(next_token_);
   }
 }
 
 void MockConnectionManager::SetChangesRemaining(int64 timestamp) {
   GetUpdateResponse()->set_changes_remaining(timestamp);
 }
 
-void MockConnectionManager::ProcessGetUpdates(ClientToServerMessage* csm,
-    ClientToServerResponse* response) {
+void MockConnectionManager::ProcessGetUpdates(
+    sync_pb::ClientToServerMessage* csm,
+    sync_pb::ClientToServerResponse* response) {
   CHECK(csm->has_get_updates());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::GET_UPDATES);
   const GetUpdatesMessage& gu = csm->get_updates();
   num_get_updates_requests_++;
   EXPECT_FALSE(gu.has_from_timestamp());
   EXPECT_FALSE(gu.has_requested_types());
 
   if (fail_non_periodic_get_updates_) {
     EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::PERIODIC,
               gu.caller_info().source());
@@ skipping 55 matching lines @@
   bool conflict = false;
   if (conflict_all_commits_) {
     conflict = true;
   } else if (conflict_n_commits_ > 0) {
     conflict = true;
     --conflict_n_commits_;
   }
   return conflict;
 }
 
-void MockConnectionManager::ProcessCommit(ClientToServerMessage* csm,
-    ClientToServerResponse* response_buffer) {
+void MockConnectionManager::ProcessCommit(
+    sync_pb::ClientToServerMessage* csm,
+    sync_pb::ClientToServerResponse* response_buffer) {
   CHECK(csm->has_commit());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::COMMIT);
   map <string, string> changed_ids;
   const CommitMessage& commit_message = csm->commit();
   CommitResponse* commit_response = response_buffer->mutable_commit();
   commit_messages_.push_back(new CommitMessage);
   commit_messages_.back()->CopyFrom(commit_message);
-  map<string, CommitResponse_EntryResponse*> response_map;
+  map<string, sync_pb::CommitResponse_EntryResponse*> response_map;
   for (int i = 0; i < commit_message.entries_size() ; i++) {
     const sync_pb::SyncEntity& entry = commit_message.entries(i);
     CHECK(entry.has_id_string());
     string id = entry.id_string();
     ASSERT_LT(entry.name().length(), 256ul) << " name probably too long. True "
         "server name checking not implemented";
     if (entry.version() == 0) {
       // Relies on our new item string id format. (string representation of a
       // negative number).
       committed_ids_.push_back(syncable::Id::CreateFromClientString(id));
     } else {
       committed_ids_.push_back(syncable::Id::CreateFromServerId(id));
     }
     if (response_map.end() == response_map.find(id))
       response_map[id] = commit_response->add_entryresponse();
-    CommitResponse_EntryResponse* er = response_map[id];
+    sync_pb::CommitResponse_EntryResponse* er = response_map[id];
     if (ShouldConflictThisCommit()) {
       er->set_response_type(CommitResponse::CONFLICT);
       continue;
     }
     er->set_response_type(CommitResponse::SUCCESS);
     er->set_version(entry.version() + 1);
     if (!commit_time_rename_prepended_string_.empty()) {
       // Commit time rename sent down from the server.
       er->set_name(commit_time_rename_prepended_string_ + entry.name());
     }
     string parent_id = entry.parent_id_string();
     // Remap id's we've already assigned.
     if (changed_ids.end() != changed_ids.find(parent_id)) {
       parent_id = changed_ids[parent_id];
       er->set_parent_id_string(parent_id);
     }
     if (entry.has_version() && 0 != entry.version()) {
       er->set_id_string(id);  // Allows verification.
     } else {
       string new_id = base::StringPrintf("mock_server:%d", next_new_id_++);
       changed_ids[id] = new_id;
       er->set_id_string(new_id);
     }
   }
   commit_responses_.push_back(new CommitResponse(*commit_response));
 }
 
-SyncEntity* MockConnectionManager::AddUpdateDirectory(
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     syncable::Id id, syncable::Id parent_id, string name, int64 version,
     int64 sync_ts) {
   return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(),
                             name, version, sync_ts);
 }
 
-SyncEntity* MockConnectionManager::AddUpdateBookmark(
+sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
     syncable::Id id, syncable::Id parent_id, string name, int64 version,
     int64 sync_ts) {
   return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
                            name, version, sync_ts);
 }
 
-SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
+sync_pb::SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
   sync_pb::GetUpdatesResponse* updates = GetUpdateResponse();
   EXPECT_GT(updates->entries_size(), 0);
   return updates->mutable_entries()->Mutable(updates->entries_size() - 1);
 }
 
 void MockConnectionManager::NextUpdateBatch() {
   update_queue_.push_back(sync_pb::GetUpdatesResponse::default_instance());
   SetChangesRemaining(0);
   ApplyToken();
 }
@@ skipping 43 matching lines @@
   server_reachable_ = false;
 }
 
 void MockConnectionManager::UpdateConnectionStatus() {
   if (!server_reachable_) {
     server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
   } else {
     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   }
 }
+
+}  // namespace syncer