[Sync] Move ModelType and related classes to 'syncer' namespace

chrome/browser/extensions/app_notification_manager_sync_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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/extensions/app_notification.h"
 #include "chrome/browser/extensions/app_notification_manager.h"
@@ skipping 245 matching lines @@
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
 }
 
 // GetAllSyncData returns all notifications since none are marked local only.
 TEST_F(AppNotificationManagerSyncTest, GetAllSyncDataNoLocal) {
   model()->Add(CreateNotificationNoLink(1));
   model()->Add(CreateNotification(2));
   model()->Add(CreateNotification(3));
   syncer::SyncDataList all_sync_data =
-      model()->GetAllSyncData(syncable::APP_NOTIFICATIONS);
+      model()->GetAllSyncData(syncer::APP_NOTIFICATIONS);
 
   EXPECT_EQ(3U, all_sync_data.size());
 
   for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
       iter != all_sync_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
 
     const std::string& guid = notif1->guid();
     const std::string& ext_id = notif1->extension_id();
 
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     ASSERT_TRUE(notif1->Equals(*notif2));
   }
 }
 
 // GetAllSyncData should not return notifications marked as local only.
 TEST_F(AppNotificationManagerSyncTest, GetAllSyncDataSomeLocal) {
   model()->Add(CreateNotificationNoLink(1));
   model()->Add(CreateNotification(true, 2));
   model()->Add(CreateNotification(3));
   model()->Add(CreateNotification(true, 4));
   model()->Add(CreateNotification(5));
   syncer::SyncDataList all_sync_data =
-      model()->GetAllSyncData(syncable::APP_NOTIFICATIONS);
+      model()->GetAllSyncData(syncer::APP_NOTIFICATIONS);
 
   EXPECT_EQ(3U, all_sync_data.size());
 
   for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
       iter != all_sync_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& guid = notif1->guid();
     const std::string& ext_id = notif1->extension_id();
 
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     ASSERT_TRUE(notif1->Equals(*notif2));
   }
 }
 
 // Model assocation: both models are empty.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothEmpty) {
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),  // Empty.
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
-  EXPECT_EQ(0U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(0U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // Model assocation: empty sync model and non-empty local model.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocModelEmpty) {
   syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(1));
   initial_data.push_back(CreateSyncData(2));
   initial_data.push_back(CreateSyncData(3));
   initial_data.push_back(CreateSyncData(4));
 
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
-  EXPECT_EQ(4U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(4U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   // Model should all of the initial sync data.
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& ext_id = notif1->extension_id();
     const std::string& guid = notif1->guid();
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     EXPECT_TRUE(notif2);
     EXPECT_TRUE(notif1->Equals(*notif2));
@@ skipping 12 matching lines @@
   AppNotification* n3 = CreateNotification(3);
   model()->Add(n3);
 
   syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(4));
   initial_data.push_back(CreateSyncData(5));
   initial_data.push_back(CreateSyncData(6));
   initial_data.push_back(CreateSyncData(7));
 
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
-  EXPECT_EQ(6U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(6U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& ext_id = notif1->extension_id();
     const std::string& guid = notif1->guid();
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     EXPECT_TRUE(notif2);
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
@@ skipping 26 matching lines @@
   syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(5));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n1));
   initial_data.push_back(CreateSyncData(6));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n4));
   initial_data.push_back(CreateSyncData(7));
 
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
-  EXPECT_EQ(6U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(6U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& ext_id = notif1->extension_id();
     const std::string& guid = notif1->guid();
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     EXPECT_TRUE(notif2);
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
@@ skipping 28 matching lines @@
       n1->body(), n1->link_url().spec(), n1->link_text()));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n1_a));
 
   scoped_ptr<syncer::SyncErrorFactoryMock> error_handler(
       new syncer::SyncErrorFactoryMock());
   EXPECT_CALL(*error_handler, CreateAndUploadError(_, _)).
       WillOnce(
           Return(
               syncer::SyncError(
-                  FROM_HERE, "error", syncable::APP_NOTIFICATIONS)));
+                  FROM_HERE, "error", syncer::APP_NOTIFICATIONS)));
 
   syncer::SyncError sync_error = model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
       error_handler.PassAs<syncer::SyncErrorFactory>());
 
   EXPECT_TRUE(sync_error.IsSet());
-  EXPECT_EQ(syncable::APP_NOTIFICATIONS, sync_error.type());
+  EXPECT_EQ(syncer::APP_NOTIFICATIONS, sync_error.type());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // When an item in sync matches with a local-only item in model, an error
 // should be returned.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothNonEmptyMatchesLocal) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(true, 2);
   model()->Add(n2);
 
   syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(1));
   scoped_ptr<AppNotification> n2_a(CreateNotification(2));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n2_a));
 
   scoped_ptr<syncer::SyncErrorFactoryMock> error_handler(
       new syncer::SyncErrorFactoryMock());
   EXPECT_CALL(*error_handler, CreateAndUploadError(_, _)).
       WillOnce(
           Return(
               syncer::SyncError(
-                  FROM_HERE, "error", syncable::APP_NOTIFICATIONS)));
+                  FROM_HERE, "error", syncer::APP_NOTIFICATIONS)));
 
   syncer::SyncError sync_error = model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
       error_handler.PassAs<syncer::SyncErrorFactory>());
 
   EXPECT_TRUE(sync_error.IsSet());
-  EXPECT_EQ(syncable::APP_NOTIFICATIONS, sync_error.type());
+  EXPECT_EQ(syncer::APP_NOTIFICATIONS, sync_error.type());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // Process sync changes when model is empty.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesEmptyModel) {
   // We initially have no data.
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Set up a bunch of ADDs.
   syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_ADD, CreateNotification(1)));
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_ADD, CreateNotification(2)));
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_ADD, CreateNotification(3)));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
-  EXPECT_EQ(3U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(3U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // Process sync changes when model is not empty.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesNonEmptyModel) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
   syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_ADD, CreateNotification(3)));
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_DELETE, n1->Copy()));
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_ADD, CreateNotification(4)));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
-  EXPECT_EQ(3U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(3U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process sync changes should ignore a bad ADD.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesIgnoreBadAdd) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
   syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_ADD, CreateNotification(1)));
 
   syncer::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_FALSE(error.IsSet());
 
-  EXPECT_EQ(2U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(2U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process sync changes should ignore a bad DELETE.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesIgnoreBadDelete) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
   syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_DELETE, CreateNotification(3)));
 
   syncer::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_FALSE(error.IsSet());
 
-  EXPECT_EQ(2U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(2U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process sync changes should ignore bad UPDATEs.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesIgnoreBadUpdates) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
   syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_UPDATE, CreateNotification(3)));
   AppNotification* n2_changed = n2->Copy();
   n2_changed->set_link_text(n2_changed->link_text() + "-changed");
   changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_UPDATE, n2_changed));
 
   syncer::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_FALSE(error.IsSet());
 
-  EXPECT_EQ(2U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+  EXPECT_EQ(2U, model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process over 15 changes when model is not empty.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesEmptyModelWithMax) {
   const std::string& ext_id = "e1";
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
   for (unsigned int i = 0;
        i < AppNotificationManager::kMaxNotificationPerApp * 2; i++) {
     syncer::SyncChangeList changes;
     changes.push_back(CreateSyncChange(
       syncer::SyncChange::ACTION_ADD, CreateNotification(false, i, ext_id)));
     model()->ProcessSyncChanges(FROM_HERE, changes);
     if (i < AppNotificationManager::kMaxNotificationPerApp) {
       EXPECT_EQ(i + 1,
-                model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+                model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
     } else {
       EXPECT_EQ(AppNotificationManager::kMaxNotificationPerApp,
-        model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+        model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
       for (unsigned int j = i; j > i - 5; j--) {
         EXPECT_EQ(
             AppNotificationManager::kMaxNotificationPerApp,
-            model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+            model()->GetAllSyncData(syncer::APP_NOTIFICATIONS).size());
       }
     }
   }
 }
 
 // Stop syncing sets state correctly.
 TEST_F(AppNotificationManagerSyncTest, StopSyncing) {
   EXPECT_FALSE(model()->sync_processor_.get());
   EXPECT_FALSE(model()->models_associated_);
 
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_TRUE(model()->sync_processor_.get());
   EXPECT_TRUE(model()->models_associated_);
 
-  model()->StopSyncing(syncable::APP_NOTIFICATIONS);
+  model()->StopSyncing(syncer::APP_NOTIFICATIONS);
   EXPECT_FALSE(model()->sync_processor_.get());
   EXPECT_FALSE(model()->models_associated_);
 }
 
 // Adds get pushed to sync but local only are skipped.
 TEST_F(AppNotificationManagerSyncTest, AddsGetsSynced) {
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       syncer::SyncDataList(),
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   AppNotification* n3 = CreateNotification(true, 2);
   model()->Add(n3);
@@ skipping 17 matching lines @@
   syncer::SyncDataList initial_data;
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n1));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n2));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n3));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n4));
   model()->MergeDataAndStartSyncing(
-      syncable::APP_NOTIFICATIONS,
+      syncer::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   model()->ClearAll(ext_id);
 
   EXPECT_EQ(3U, processor()->change_list_size());
   EXPECT_TRUE(processor()->ContainsGuid(n1->guid()));
   syncer::SyncChange c1 = processor()->GetChangeByGuid(n1->guid());
   AssertSyncChange(c1, syncer::SyncChange::ACTION_DELETE, *n1);
   syncer::SyncChange c2 = processor()->GetChangeByGuid(n2->guid());
   AssertSyncChange(c2, syncer::SyncChange::ACTION_DELETE, *n2);
   syncer::SyncChange c3 = processor()->GetChangeByGuid(n3->guid());
   AssertSyncChange(c3, syncer::SyncChange::ACTION_DELETE, *n3);
 }