[Sync] Put everything in sync/api into csync namespace

chrome/browser/extensions/extension_service.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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 685 matching lines @@
         extension.get(), error)) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
     return false;
   }
 
   // Extract the data we need for sync now, but don't actually sync until we've
   // completed the uninstallation.
-  SyncChange sync_change;
+  csync::SyncChange sync_change;
   if (app_sync_bundle_.HandlesApp(*extension)) {
     sync_change = app_sync_bundle_.CreateSyncChangeToDelete(extension);
   } else if (extension_sync_bundle_.HandlesExtension(*extension)) {
     sync_change = extension_sync_bundle_.CreateSyncChangeToDelete(extension);
   }
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UninstallType",
                             extension->GetType(), 100);
   RecordPermissionMessagesHistogram(
       extension, "Extensions.Permissions_Uninstall");
@@ skipping 464 matching lines @@
       // Sync can start updating before all the external providers are ready
       // during startup. Start the update as soon as those providers are ready,
       // but not before.
       update_once_all_providers_are_ready_ = true;
     }
   } else {
     LOG(WARNING) << "CheckForUpdatesSoon() called with auto-update turned off";
   }
 }
 
-SyncError ExtensionService::MergeDataAndStartSyncing(
+csync::SyncError ExtensionService::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(sync_processor.get());
   CHECK(sync_error_factory.get());
 
   switch (type) {
     case syncable::EXTENSIONS:
       extension_sync_bundle_.SetupSync(sync_processor.release(),
                                        sync_error_factory.release(),
                                        initial_sync_data);
       break;
 
     case syncable::APPS:
       app_sync_bundle_.SetupSync(sync_processor.release(),
                                  sync_error_factory.release(),
                                  initial_sync_data);
       break;
 
     default:
       LOG(FATAL) << "Got " << type << " ModelType";
   }
 
   // Process local extensions.
   // TODO(yoz): Determine whether pending extensions should be considered too.
   //            See crbug.com/104399.
-  SyncDataList sync_data_list = GetAllSyncData(type);
-  SyncChangeList sync_change_list;
-  for (SyncDataList::const_iterator i = sync_data_list.begin();
+  csync::SyncDataList sync_data_list = GetAllSyncData(type);
+  csync::SyncChangeList sync_change_list;
+  for (csync::SyncDataList::const_iterator i = sync_data_list.begin();
        i != sync_data_list.end();
        ++i) {
     switch (type) {
         case syncable::EXTENSIONS:
           sync_change_list.push_back(
               extension_sync_bundle_.CreateSyncChange(*i));
           break;
         case syncable::APPS:
           sync_change_list.push_back(app_sync_bundle_.CreateSyncChange(*i));
           break;
       default:
         LOG(FATAL) << "Got " << type << " ModelType";
       }
   }
 
 
   if (type == syncable::EXTENSIONS) {
     extension_sync_bundle_.ProcessSyncChangeList(sync_change_list);
   } else if (type == syncable::APPS) {
     app_sync_bundle_.ProcessSyncChangeList(sync_change_list);
   }
 
-  return SyncError();
+  return csync::SyncError();
 }
 
 void ExtensionService::StopSyncing(syncable::ModelType type) {
   if (type == syncable::APPS) {
     app_sync_bundle_.Reset();
   } else if (type == syncable::EXTENSIONS) {
     extension_sync_bundle_.Reset();
   }
 }
 
-SyncDataList ExtensionService::GetAllSyncData(syncable::ModelType type) const {
+csync::SyncDataList ExtensionService::GetAllSyncData(
+    syncable::ModelType type) const {
   if (type == syncable::EXTENSIONS) {
     return extension_sync_bundle_.GetAllSyncData();
 
   } else if (type == syncable::APPS) {
     return app_sync_bundle_.GetAllSyncData();
   }
 
   // We should only get sync data for extensions and apps.
   NOTREACHED();
 
-  return SyncDataList();
+  return csync::SyncDataList();
 }
 
-SyncError ExtensionService::ProcessSyncChanges(
+csync::SyncError ExtensionService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const SyncChangeList& change_list) {
-  for (SyncChangeList::const_iterator i = change_list.begin();
+    const csync::SyncChangeList& change_list) {
+  for (csync::SyncChangeList::const_iterator i = change_list.begin();
       i != change_list.end();
       ++i) {
     syncable::ModelType type = i->sync_data().GetDataType();
     if (type == syncable::EXTENSIONS) {
       extension_sync_bundle_.ProcessSyncChange(
           extensions::ExtensionSyncData(*i));
     } else if (type == syncable::APPS) {
       app_sync_bundle_.ProcessSyncChange(extensions::AppSyncData(*i));
     }
   }
 
   extension_prefs()->extension_sorting()->FixNTPOrdinalCollisions();
 
-  return SyncError();
+  return csync::SyncError();
 }
 
 extensions::ExtensionSyncData ExtensionService::GetExtensionSyncData(
     const Extension& extension) const {
   return extensions::ExtensionSyncData(extension,
                                        IsExtensionEnabled(extension.id()),
                                        IsIncognitoEnabled(extension.id()));
 }
 
 extensions::AppSyncData ExtensionService::GetAppSyncData(
@@ skipping 1259 matching lines @@
 
   // To coexist with certain unit tests that don't have a work-thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy an
   // APIResourceController.
   if (!api_resource_controller_.get()) {
     api_resource_controller_.reset(new extensions::APIResourceController());
   }
   return api_resource_controller_.get();
 }