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

chrome/browser/extensions/app_notification_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.
 
 #include "chrome/browser/extensions/app_notification_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/location.h"
@@ skipping 161 matching lines @@
 
 void AppNotificationManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   CHECK(type == chrome::NOTIFICATION_EXTENSION_UNINSTALLED);
   ClearAll(*content::Details<const std::string>(details).ptr());
 }
 
 syncer::SyncDataList AppNotificationManager::GetAllSyncData(
-    syncable::ModelType type) const {
+    syncer::ModelType type) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(loaded());
-  DCHECK_EQ(syncable::APP_NOTIFICATIONS, type);
+  DCHECK_EQ(syncer::APP_NOTIFICATIONS, type);
   syncer::SyncDataList data;
   for (NotificationMap::const_iterator iter = notifications_->begin();
       iter != notifications_->end(); ++iter) {
 
     // Skip local notifications since they should not be synced.
     const AppNotificationList list = (*iter).second;
     for (AppNotificationList::const_iterator list_iter = list.begin();
         list_iter != list.end(); ++list_iter) {
       const AppNotification* notification = (*list_iter).get();
       if (notification->is_local()) {
@@ skipping 16 matching lines @@
         FROM_HERE,
         "Models not yet associated.");
   }
 
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   syncer::SyncError error;
   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
        iter != change_list.end(); ++iter) {
     syncer::SyncData sync_data = iter->sync_data();
-    DCHECK_EQ(syncable::APP_NOTIFICATIONS, sync_data.GetDataType());
+    DCHECK_EQ(syncer::APP_NOTIFICATIONS, sync_data.GetDataType());
     syncer::SyncChange::SyncChangeType change_type = iter->change_type();
 
     scoped_ptr<AppNotification> new_notif(CreateNotificationFromSyncData(
         sync_data));
     if (!new_notif.get()) {
       NOTREACHED() << "Failed to read notification.";
       continue;
     }
     const AppNotification* existing_notif = GetNotification(
         new_notif->extension_id(), new_notif->guid());
@@ skipping 44 matching lines @@
         break;
       default:
         break;
     }
   }
 
   return error;
 }
 
 syncer::SyncError AppNotificationManager::MergeDataAndStartSyncing(
-    syncable::ModelType type,
+    syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // AppNotificationDataTypeController ensures that modei is fully should before
   // this method is called by waiting until the load notification is received
   // from AppNotificationManager.
   DCHECK(loaded());
-  DCHECK_EQ(type, syncable::APP_NOTIFICATIONS);
+  DCHECK_EQ(type, syncer::APP_NOTIFICATIONS);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
   sync_processor_ = sync_processor.Pass();
   sync_error_factory_ = sync_error_factory.Pass();
 
   // We may add, or remove notifications here, so ensure we don't step on
   // our own toes.
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   SyncDataMap local_data_map;
-  PopulateGuidToSyncDataMap(GetAllSyncData(syncable::APP_NOTIFICATIONS),
+  PopulateGuidToSyncDataMap(GetAllSyncData(syncer::APP_NOTIFICATIONS),
                             &local_data_map);
 
   for (syncer::SyncDataList::const_iterator iter = initial_sync_data.begin();
        iter != initial_sync_data.end(); ++iter) {
     const syncer::SyncData& sync_data = *iter;
-    DCHECK_EQ(syncable::APP_NOTIFICATIONS, sync_data.GetDataType());
+    DCHECK_EQ(syncer::APP_NOTIFICATIONS, sync_data.GetDataType());
     scoped_ptr<AppNotification> sync_notif(CreateNotificationFromSyncData(
         sync_data));
     CHECK(sync_notif.get());
     const AppNotification* local_notif = GetNotification(
         sync_notif->extension_id(), sync_notif->guid());
     if (local_notif) {
       local_data_map.erase(sync_notif->guid());
       // Local notification should always match with sync notification as
       // notifications are immutable.
       if (local_notif->is_local() || !sync_notif->Equals(*local_notif)) {
@@ skipping 16 matching lines @@
         syncer::SyncChange(syncer::SyncChange::ACTION_ADD, iter->second));
   }
 
   syncer::SyncError error;
   if (new_changes.size() > 0)
     error = sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
   models_associated_ = !error.IsSet();
   return error;
 }
 
-void AppNotificationManager::StopSyncing(syncable::ModelType type) {
-  DCHECK_EQ(type, syncable::APP_NOTIFICATIONS);
+void AppNotificationManager::StopSyncing(syncer::ModelType type) {
+  DCHECK_EQ(type, syncer::APP_NOTIFICATIONS);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
 }
 
 AppNotificationManager::~AppNotificationManager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Post a task to delete our storage on the file thread.
   BrowserThread::DeleteSoon(BrowserThread::FILE,
                             FROM_HERE,
@@ skipping 207 matching lines @@
   AppNotification* notification = new AppNotification(
       false, base::Time::FromInternalValue(specifics.creation_timestamp_ms()),
       specifics.guid(), specifics.app_id(),
       specifics.title(), specifics.body_text());
   if (specifics.has_link_text())
     notification->set_link_text(specifics.link_text());
   if (specifics.has_link_url())
     notification->set_link_url(GURL(specifics.link_url()));
   return notification;
 }