sync: rename ProfileSyncFactory to ProfileSyncComponentsFactory.

chrome/browser/sync/profile_sync_components_factory_impl.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "chrome/browser/extensions/app_notification_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/settings/settings_backend.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 21 matching lines @@
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/shared_change_processor.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/syncable_service_adapter.h"
 #include "chrome/browser/sync/glue/theme_change_processor.h"
 #include "chrome/browser/sync/glue/theme_data_type_controller.h"
 #include "chrome/browser/sync/glue/theme_model_associator.h"
 #include "chrome/browser/sync/glue/typed_url_change_processor.h"
 #include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
 #include "chrome/browser/sync/glue/typed_url_model_associator.h"
-#include "chrome/browser/sync/profile_sync_factory_impl.h"
+#include "chrome/browser/sync/profile_sync_components_factory_impl.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/signin_manager.h"
 #include "chrome/browser/webdata/autocomplete_syncable_service.h"
 #include "chrome/browser/webdata/autofill_profile_syncable_service.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 
 using browser_sync::AppDataTypeController;
@@ skipping 22 matching lines @@
 using browser_sync::SyncBackendHost;
 using browser_sync::ThemeChangeProcessor;
 using browser_sync::ThemeDataTypeController;
 using browser_sync::ThemeModelAssociator;
 using browser_sync::TypedUrlChangeProcessor;
 using browser_sync::TypedUrlDataTypeController;
 using browser_sync::TypedUrlModelAssociator;
 using browser_sync::UnrecoverableErrorHandler;
 using content::BrowserThread;
 
-ProfileSyncFactoryImpl::ProfileSyncFactoryImpl(Profile* profile,
-                                               CommandLine* command_line)
+ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl(
+    Profile* profile, CommandLine* command_line)
     : profile_(profile),
       command_line_(command_line) {
 }
 
-ProfileSyncService* ProfileSyncFactoryImpl::CreateProfileSyncService(
+ProfileSyncService* ProfileSyncComponentsFactoryImpl::CreateProfileSyncService(
     const std::string& cros_user) {
 
   ProfileSyncService* pss = new ProfileSyncService(
       this, profile_, new SigninManager(), cros_user);
   return pss;
 }
 
-void ProfileSyncFactoryImpl::RegisterDataTypes(ProfileSyncService* pss) {
+void ProfileSyncComponentsFactoryImpl::RegisterDataTypes(
+    ProfileSyncService* pss) {
   // App sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!command_line_->HasSwitch(switches::kDisableSyncApps)) {
     pss->RegisterDataTypeController(
         new AppDataTypeController(this, profile_, pss));
   }
 
   // Autofill sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!command_line_->HasSwitch(switches::kDisableSyncAutofill)) {
@@ skipping 74 matching lines @@
   }
 
   // App notifications sync is enabled by default.  Register only if
   // explicitly disabled.
   if (!command_line_->HasSwitch(switches::kDisableSyncAppNotifications)) {
     pss->RegisterDataTypeController(
         new AppNotificationDataTypeController(this, profile_, pss));
   }
 }
 
-DataTypeManager* ProfileSyncFactoryImpl::CreateDataTypeManager(
+DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
     SyncBackendHost* backend,
     const DataTypeController::TypeMap* controllers) {
   return new DataTypeManagerImpl(backend, controllers);
 }
 
 browser_sync::GenericChangeProcessor*
-    ProfileSyncFactoryImpl::CreateGenericChangeProcessor(
+    ProfileSyncComponentsFactoryImpl::CreateGenericChangeProcessor(
         ProfileSyncService* profile_sync_service,
         browser_sync::UnrecoverableErrorHandler* error_handler,
         const base::WeakPtr<SyncableService>& local_service) {
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   return new GenericChangeProcessor(error_handler,
                                     local_service,
                                     user_share);
 }
 
-browser_sync::SharedChangeProcessor* ProfileSyncFactoryImpl::
+browser_sync::SharedChangeProcessor* ProfileSyncComponentsFactoryImpl::
     CreateSharedChangeProcessor() {
   return new SharedChangeProcessor();
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateAppSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateAppSyncComponents(

[Nicolas Zea, 2011/11/22 00:01:03]

although all the methods in this file match this format, indent by 4 spaces
here?

[tim (not reviewing), 2011/11/22 00:38:20]

think we'd generally say consistency trumps the rule here :/ I suppose i can
change them all, if you really want to overturn the decision :)

     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   base::WeakPtr<SyncableService> app_sync_service =
       profile_sync_service->profile()->GetExtensionService()->AsWeakPtr();
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(error_handler, app_sync_service, user_share);
   browser_sync::SyncableServiceAdapter* sync_service_adapter =
       new browser_sync::SyncableServiceAdapter(syncable::APPS,
                                                app_sync_service,
                                                change_processor);
   return SyncComponents(sync_service_adapter, change_processor);
 }
 
 base::WeakPtr<SyncableService>
-ProfileSyncFactoryImpl::GetAutofillProfileSyncableService(
+ProfileSyncComponentsFactoryImpl::GetAutofillProfileSyncableService(
     WebDataService* web_data_service) const {
   return web_data_service->GetAutofillProfileSyncableService()->AsWeakPtr();
 }
 
 base::WeakPtr<SyncableService>
-ProfileSyncFactoryImpl::GetAutocompleteSyncableService(
+ProfileSyncComponentsFactoryImpl::GetAutocompleteSyncableService(
     WebDataService* web_data_service) const {
   return web_data_service->GetAutocompleteSyncableService()->AsWeakPtr();
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateBookmarkSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents(
     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   BookmarkModel* bookmark_model =
       profile_sync_service->profile()->GetBookmarkModel();
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   BookmarkModelAssociator* model_associator =
       new BookmarkModelAssociator(bookmark_model,
                                   user_share,
                                   error_handler);
   BookmarkChangeProcessor* change_processor =
       new BookmarkChangeProcessor(model_associator,
                                   error_handler);
   return SyncComponents(model_associator, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateExtensionOrAppSettingSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateExtensionOrAppSettingSyncComponents(
     syncable::ModelType type,
     SyncableService* settings_service,
     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(type == syncable::EXTENSION_SETTINGS ||
          type == syncable::APP_SETTINGS);
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(error_handler,
                                  settings_service->AsWeakPtr(),
                                  user_share);
   browser_sync::SyncableServiceAdapter* sync_service_adapter =
       new browser_sync::SyncableServiceAdapter(type,
                                                settings_service,
                                                change_processor);
   return SyncComponents(sync_service_adapter, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateExtensionSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateExtensionSyncComponents(
     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   base::WeakPtr<SyncableService> extension_sync_service =
       profile_sync_service->profile()->GetExtensionService()->AsWeakPtr();
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(error_handler,
                                  extension_sync_service,
                                  user_share);
   browser_sync::SyncableServiceAdapter* sync_service_adapter =
       new browser_sync::SyncableServiceAdapter(syncable::EXTENSIONS,
                                                extension_sync_service,
                                                change_processor);
   return SyncComponents(sync_service_adapter, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreatePasswordSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreatePasswordSyncComponents(
     ProfileSyncService* profile_sync_service,
     PasswordStore* password_store,
     UnrecoverableErrorHandler* error_handler) {
   PasswordModelAssociator* model_associator =
       new PasswordModelAssociator(profile_sync_service,
                                   password_store);
   PasswordChangeProcessor* change_processor =
       new PasswordChangeProcessor(model_associator,
                                   password_store,
                                   error_handler);
   return SyncComponents(model_associator, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreatePreferenceSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreatePreferenceSyncComponents(
     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   base::WeakPtr<SyncableService> pref_sync_service =
       profile_->GetPrefs()->GetSyncableService()->AsWeakPtr();
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(error_handler,
                                  pref_sync_service,
                                  user_share);
   SyncableServiceAdapter* sync_service_adapter =
       new SyncableServiceAdapter(syncable::PREFERENCES,
                                  pref_sync_service,
                                  change_processor);
   return SyncComponents(sync_service_adapter, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateThemeSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateThemeSyncComponents(
     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   ThemeModelAssociator* model_associator =
       new ThemeModelAssociator(profile_sync_service);
   ThemeChangeProcessor* change_processor =
       new ThemeChangeProcessor(error_handler);
   return SyncComponents(model_associator, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateTypedUrlSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateTypedUrlSyncComponents(
     ProfileSyncService* profile_sync_service,
     history::HistoryBackend* history_backend,
     browser_sync::UnrecoverableErrorHandler* error_handler) {
   TypedUrlModelAssociator* model_associator =
       new TypedUrlModelAssociator(profile_sync_service,
                                   history_backend);
   TypedUrlChangeProcessor* change_processor =
       new TypedUrlChangeProcessor(profile_,
                                   model_associator,
                                   history_backend,
                                   error_handler);
   return SyncComponents(model_associator, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateSessionSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateSessionSyncComponents(
     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   SessionModelAssociator* model_associator =
       new SessionModelAssociator(profile_sync_service);
   SessionChangeProcessor* change_processor =
       new SessionChangeProcessor(error_handler, model_associator);
   return SyncComponents(model_associator, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateSearchEngineSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateSearchEngineSyncComponents(
     ProfileSyncService* profile_sync_service,
     UnrecoverableErrorHandler* error_handler) {
   base::WeakPtr<SyncableService> se_sync_service =
       TemplateURLServiceFactory::GetForProfile(profile_)->AsWeakPtr();
   DCHECK(se_sync_service);
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(error_handler,
                                  se_sync_service,
                                  user_share);
   SyncableServiceAdapter* sync_service_adapter =
       new SyncableServiceAdapter(syncable::SEARCH_ENGINES,
                                  se_sync_service,
                                  change_processor);
   return SyncComponents(sync_service_adapter, change_processor);
 }
 
-ProfileSyncFactory::SyncComponents
-ProfileSyncFactoryImpl::CreateAppNotificationSyncComponents(
+ProfileSyncComponentsFactory::SyncComponents
+ProfileSyncComponentsFactoryImpl::CreateAppNotificationSyncComponents(
     ProfileSyncService* profile_sync_service,
     browser_sync::UnrecoverableErrorHandler* error_handler) {
   base::WeakPtr<SyncableService> notif_sync_service =
       profile_->GetExtensionService()->app_notification_manager()->AsWeakPtr();
   DCHECK(notif_sync_service);
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(error_handler,
                                  notif_sync_service,
                                  user_share);
   SyncableServiceAdapter* sync_service_adapter =
       new SyncableServiceAdapter(syncable::APP_NOTIFICATIONS,
                                  notif_sync_service,
                                  change_processor);
   return SyncComponents(sync_service_adapter, change_processor);
 }