[Sync] Put everything in sync/api into csync 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"
 #include "base/metrics/histogram.h"
 #include "base/perftimer.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/notification_service.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/app_notification_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 
 using content::BrowserThread;
 
-typedef std::map<std::string, SyncData> SyncDataMap;
+typedef std::map<std::string, csync::SyncData> SyncDataMap;
 
 namespace {
 
 class GuidComparator
     : public std::binary_function<linked_ptr<AppNotification>,
                                   std::string,
                                   bool> {
  public:
   bool operator() (linked_ptr<AppNotification> notif,
                    const std::string& guid) const {
@@ skipping 11 matching lines @@
 void RemoveByGuid(AppNotificationList* list, const std::string& guid) {
   if (!list)
     return;
 
   AppNotificationList::iterator iter = std::find_if(
       list->begin(), list->end(), std::bind2nd(GuidComparator(), guid));
   if (iter != list->end())
     list->erase(iter);
 }
 
-void PopulateGuidToSyncDataMap(const SyncDataList& sync_data,
+void PopulateGuidToSyncDataMap(const csync::SyncDataList& sync_data,
                                SyncDataMap* data_map) {
-  for (SyncDataList::const_iterator iter = sync_data.begin();
+  for (csync::SyncDataList::const_iterator iter = sync_data.begin();
        iter != sync_data.end(); ++iter) {
     (*data_map)[iter->GetSpecifics().app_notification().guid()] = *iter;
   }
 }
 }  // namespace
 
 const unsigned int AppNotificationManager::kMaxNotificationPerApp = 5;
 
 AppNotificationManager::AppNotificationManager(Profile* profile)
     : profile_(profile),
@@ skipping 101 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());
 }
 
-SyncDataList AppNotificationManager::GetAllSyncData(
+csync::SyncDataList AppNotificationManager::GetAllSyncData(
     syncable::ModelType type) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(loaded());
   DCHECK_EQ(syncable::APP_NOTIFICATIONS, type);
-  SyncDataList data;
+  csync::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()) {
         continue;
       }
       data.push_back(CreateSyncDataFromNotification(*notification));
     }
   }
 
   return data;
 }
 
-SyncError AppNotificationManager::ProcessSyncChanges(
+csync::SyncError AppNotificationManager::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const SyncChangeList& change_list) {
+    const csync::SyncChangeList& change_list) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(loaded());
   if (!models_associated_) {
     return sync_error_factory_->CreateAndUploadError(
         FROM_HERE,
         "Models not yet associated.");
   }
 
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
-  SyncError error;
-  for (SyncChangeList::const_iterator iter = change_list.begin();
+  csync::SyncError error;
+  for (csync::SyncChangeList::const_iterator iter = change_list.begin();
        iter != change_list.end(); ++iter) {
-    SyncData sync_data = iter->sync_data();
+    csync::SyncData sync_data = iter->sync_data();
     DCHECK_EQ(syncable::APP_NOTIFICATIONS, sync_data.GetDataType());
-    SyncChange::SyncChangeType change_type = iter->change_type();
+    csync::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());
     if (existing_notif && existing_notif->is_local()) {
       NOTREACHED() << "Matched with notification marked as local";
       error = sync_error_factory_->CreateAndUploadError(
           FROM_HERE,
           "ProcessSyncChanges received a local only notification" +
-              SyncChange::ChangeTypeToString(change_type));
+              csync::SyncChange::ChangeTypeToString(change_type));
       continue;
     }
 
     switch (change_type) {
-      case SyncChange::ACTION_ADD:
+      case csync::SyncChange::ACTION_ADD:
         if (!existing_notif) {
           Add(new_notif.release());
         } else {
           DLOG(ERROR) << "Got ADD change for an existing item.\n"
                       << "Existing item: " << existing_notif->ToString()
                       << "\nItem in ADD change: " << new_notif->ToString();
         }
         break;
-      case SyncChange::ACTION_DELETE:
+      case csync::SyncChange::ACTION_DELETE:
         if (existing_notif) {
           Remove(new_notif->extension_id(), new_notif->guid());
         } else {
           // This should never happen. But we are seeting this sometimes, and
           // it stops all of sync. See bug http://crbug.com/108088
           // So until we figure out the root cause, log an error and ignore.
           DLOG(ERROR) << "Got DELETE change for non-existing item.\n"
                       << "Item in DELETE change: " << new_notif->ToString();
         }
         break;
-      case SyncChange::ACTION_UPDATE:
+      case csync::SyncChange::ACTION_UPDATE:
         // Although app notifications are immutable from the model perspective,
         // sync can send UPDATE changes due to encryption / meta-data changes.
         // So ignore UPDATE changes when the exitsing and new notification
         // objects are the same. Log an error otherwise.
         if (!existing_notif) {
           DLOG(ERROR) << "Got UPDATE change for non-existing item."
                       << "Item in UPDATE change: " << new_notif->ToString();
         } else if (!existing_notif->Equals(*new_notif)) {
           DLOG(ERROR) << "Got invalid UPDATE change:"
                       << "New and existing notifications should be the same.\n"
                       << "Existing item: " << existing_notif->ToString() << "\n"
                       << "Item in UPDATE change: " << new_notif->ToString();
         }
         break;
       default:
         break;
     }
   }
 
   return error;
 }
 
-SyncError AppNotificationManager::MergeDataAndStartSyncing(
+csync::SyncError AppNotificationManager::MergeDataAndStartSyncing(
     syncable::ModelType type,
-    const SyncDataList& initial_sync_data,
-    scoped_ptr<SyncChangeProcessor> sync_processor,
-    scoped_ptr<SyncErrorFactory> sync_error_factory) {
+    const csync::SyncDataList& initial_sync_data,
+    scoped_ptr<csync::SyncChangeProcessor> sync_processor,
+    scoped_ptr<csync::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(!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),
                             &local_data_map);
 
-  for (SyncDataList::const_iterator iter = initial_sync_data.begin();
+  for (csync::SyncDataList::const_iterator iter = initial_sync_data.begin();
        iter != initial_sync_data.end(); ++iter) {
-    const SyncData& sync_data = *iter;
+    const csync::SyncData& sync_data = *iter;
     DCHECK_EQ(syncable::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)) {
         return sync_error_factory_->CreateAndUploadError(
              FROM_HERE,
             "MergeDataAndStartSyncing failed: local notification and sync "
             "notification have same guid but different data.");
       }
     } else {
       // Sync model has a notification that local model does not, add it.
       Add(sync_notif.release());
     }
   }
 
   // TODO(munjal): crbug.com/10059. Work with Lingesh/Antony to resolve.
-  SyncChangeList new_changes;
+  csync::SyncChangeList new_changes;
   for (SyncDataMap::const_iterator iter = local_data_map.begin();
       iter != local_data_map.end(); ++iter) {
-    new_changes.push_back(SyncChange(SyncChange::ACTION_ADD, iter->second));
+    new_changes.push_back(
+        csync::SyncChange(csync::SyncChange::ACTION_ADD, iter->second));
   }
 
-  SyncError error;
+  csync::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);
   models_associated_ = false;
   sync_processor_.reset();
@@ skipping 129 matching lines @@
 void AppNotificationManager::SyncAddChange(const AppNotification& notif) {
   // Skip if either:
   // - Notification is marked as local.
   // - Sync is not enabled by user.
   // - Change is generated from within the manager.
   if (notif.is_local() || !models_associated_ || processing_syncer_changes_)
     return;
 
   // TODO(munjal): crbug.com/10059. Work with Lingesh/Antony to resolve.
 
-  SyncChangeList changes;
-  SyncData sync_data = CreateSyncDataFromNotification(notif);
-  changes.push_back(SyncChange(SyncChange::ACTION_ADD, sync_data));
+  csync::SyncChangeList changes;
+  csync::SyncData sync_data = CreateSyncDataFromNotification(notif);
+  changes.push_back(
+      csync::SyncChange(csync::SyncChange::ACTION_ADD, sync_data));
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void AppNotificationManager::SyncRemoveChange(const AppNotification& notif) {
   // Skip if either:
   // - Sync is not enabled by user.
   // - Change is generated from within the manager.
   if (notif.is_local() || !models_associated_) {
     return;
   }
 
-  SyncChangeList changes;
-  SyncData sync_data = CreateSyncDataFromNotification(notif);
-  changes.push_back(SyncChange(SyncChange::ACTION_DELETE, sync_data));
+  csync::SyncChangeList changes;
+  csync::SyncData sync_data = CreateSyncDataFromNotification(notif);
+  changes.push_back(
+      csync::SyncChange(csync::SyncChange::ACTION_DELETE, sync_data));
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void AppNotificationManager::SyncClearAllChange(
   const AppNotificationList& list) {
   // Skip if either:
   // - Sync is not enabled by user.
   // - Change is generated from within the manager.
   if (!models_associated_ || processing_syncer_changes_)
     return;
 
-  SyncChangeList changes;
+  csync::SyncChangeList changes;
   for (AppNotificationList::const_iterator iter = list.begin();
       iter != list.end(); ++iter) {
     const AppNotification& notif = *iter->get();
     // Skip notifications marked as local.
     if (notif.is_local())
       continue;
-    changes.push_back(SyncChange(
-        SyncChange::ACTION_DELETE,
+    changes.push_back(csync::SyncChange(
+        csync::SyncChange::ACTION_DELETE,
         CreateSyncDataFromNotification(notif)));
   }
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 // static
-SyncData AppNotificationManager::CreateSyncDataFromNotification(
+csync::SyncData AppNotificationManager::CreateSyncDataFromNotification(
     const AppNotification& notification) {
   DCHECK(!notification.is_local());
   sync_pb::EntitySpecifics specifics;
   sync_pb::AppNotification* notif_specifics =
       specifics.mutable_app_notification();
   notif_specifics->set_app_id(notification.extension_id());
   notif_specifics->set_creation_timestamp_ms(
       notification.creation_time().ToInternalValue());
   notif_specifics->set_body_text(notification.body());
   notif_specifics->set_guid(notification.guid());
   notif_specifics->set_link_text(notification.link_text());
   notif_specifics->set_link_url(notification.link_url().spec());
   notif_specifics->set_title(notification.title());
-  return SyncData::CreateLocalData(
+  return csync::SyncData::CreateLocalData(
       notif_specifics->guid(), notif_specifics->app_id(), specifics);
 }
 
 // static
 AppNotification* AppNotificationManager::CreateNotificationFromSyncData(
-    const SyncData& sync_data) {
+    const csync::SyncData& sync_data) {
   sync_pb::AppNotification specifics =
       sync_data.GetSpecifics().app_notification();
 
   // Check for mandatory fields.
   if (!specifics.has_app_id() || !specifics.has_guid() ||
       !specifics.has_title() || !specifics.has_body_text() ||
       !specifics.has_creation_timestamp_ms()) {
     return NULL;
   }
 
   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;
 }