[Sync] Move ModelType and related classes to '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 std::map;
 using std::string;
 using sync_pb::CommitMessage;
 using sync_pb::CommitResponse;
 using sync_pb::GetUpdatesMessage;
 using sync_pb::SyncEnums;
 
 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),
       conflict_all_commits_(false),
       conflict_n_commits_(0),
       next_new_id_(10000),
@@ skipping 198 matching lines @@
   ent->set_folder(is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::SetNigori(
     int id, int64 version,int64 sync_ts,
     const sync_pb::EntitySpecifics& specifics) {
   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_server_defined_unique_tag(syncer::ModelTypeToRootTag(
+      syncer::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;
@@ skipping 135 matching lines @@
   EXPECT_FALSE(gu.has_requested_types());
 
   if (fail_non_periodic_get_updates_) {
     EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::PERIODIC,
               gu.caller_info().source());
   }
 
   // Verify that the GetUpdates filter sent by the Syncer matches the test
   // expectation.
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
-    ModelType model_type = syncable::ModelTypeFromInt(i);
+    ModelType model_type = syncer::ModelTypeFromInt(i);
     sync_pb::DataTypeProgressMarker const* progress_marker =
         GetProgressMarkerForType(gu.from_progress_marker(), model_type);
     EXPECT_EQ(expected_filter_.Has(model_type), (progress_marker != NULL))
         << "Syncer requested_types differs from test expectation.";
     if (progress_marker) {
       EXPECT_EQ((expected_payloads_.count(model_type) > 0 ?
                  expected_payloads_[model_type] :
                  std::string()),
                 progress_marker->notification_hint());
     }
   }
 
   // Verify that the items we're about to send back to the client are of
   // the types requested by the client.  If this fails, it probably indicates
   // a test bug.
   EXPECT_TRUE(gu.fetch_folders());
   EXPECT_FALSE(gu.has_requested_types());
   if (update_queue_.empty()) {
     GetUpdateResponse();
   }
   sync_pb::GetUpdatesResponse* updates = &update_queue_.front();
   for (int i = 0; i < updates->entries_size(); ++i) {
     if (!updates->entries(i).deleted()) {
-      ModelType entry_type = syncable::GetModelType(updates->entries(i));
+      ModelType entry_type = syncer::GetModelType(updates->entries(i));
       EXPECT_TRUE(
         IsModelTypePresentInSpecifics(gu.from_progress_marker(), entry_type))
           << "Syncer did not request updates being provided by the test.";
     }
   }
 
   response->mutable_get_updates()->CopyFrom(*updates);
 
   // Set appropriate progress markers, overriding the value squirreled
   // away by ApplyToken().
@@ skipping 108 matching lines @@
 }
 
 const CommitResponse& MockConnectionManager::last_commit_response() const {
   EXPECT_TRUE(!commit_responses_.empty());
   return *commit_responses_.back();
 }
 
 bool MockConnectionManager::IsModelTypePresentInSpecifics(
     const google::protobuf::RepeatedPtrField<
         sync_pb::DataTypeProgressMarker>& filter,
-    syncable::ModelType value) {
-  int data_type_id = syncable::GetSpecificsFieldNumberFromModelType(value);
+    syncer::ModelType value) {
+  int data_type_id = syncer::GetSpecificsFieldNumberFromModelType(value);
   for (int i = 0; i < filter.size(); ++i) {
     if (filter.Get(i).data_type_id() == data_type_id) {
       return true;
     }
   }
   return false;
 }
 
 sync_pb::DataTypeProgressMarker const*
     MockConnectionManager::GetProgressMarkerForType(
         const google::protobuf::RepeatedPtrField<
             sync_pb::DataTypeProgressMarker>& filter,
-        syncable::ModelType value) {
-  int data_type_id = syncable::GetSpecificsFieldNumberFromModelType(value);
+        syncer::ModelType value) {
+  int data_type_id = syncer::GetSpecificsFieldNumberFromModelType(value);
   for (int i = 0; i < filter.size(); ++i) {
     if (filter.Get(i).data_type_id() == data_type_id) {
       return &(filter.Get(i));
     }
   }
   return NULL;
 }
 
 void MockConnectionManager::SetServerReachable() {
   server_reachable_ = true;
 }
 
 void MockConnectionManager::SetServerNotReachable() {
   server_reachable_ = false;
 }
 
 void MockConnectionManager::UpdateConnectionStatus() {
   if (!server_reachable_) {
     server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
   } else {
     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   }
 }
 
 }  // namespace syncer