Revert 288557 "[Sync] Use OnSingleDataTypeUnrecoverableError for..."

trunk/src/chrome/browser/sync/profile_sync_components_factory_impl.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/command_line.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/enhanced_bookmarks_features.h"
 #include "chrome/browser/dom_distiller/dom_distiller_service_factory.h"
 #include "chrome/browser/history/history_service.h"
@@ skipping 161 matching lines @@
   syncer::ModelTypeSet disabled_types =
       GetDisabledTypesFromCommandLine(*command_line_);
   syncer::ModelTypeSet enabled_types =
       GetEnabledTypesFromCommandLine(*command_line_);
   RegisterCommonDataTypes(disabled_types, enabled_types, pss);
 #if !defined(OS_ANDROID)
   RegisterDesktopDataTypes(disabled_types, enabled_types, pss);
 #endif
 }
 
+void ProfileSyncComponentsFactoryImpl::DisableBrokenType(
+    syncer::ModelType type,
+    const tracked_objects::Location& from_here,
+    const std::string& message) {
+  ProfileSyncService* p = ProfileSyncServiceFactory::GetForProfile(profile_);
+  syncer::SyncError error(
+      from_here, syncer::SyncError::DATATYPE_ERROR, message, type);
+  p->DisableDatatype(error);
+}
+
+DataTypeController::DisableTypeCallback
+ProfileSyncComponentsFactoryImpl::MakeDisableCallbackFor(
+    syncer::ModelType type) {
+  return base::Bind(&ProfileSyncComponentsFactoryImpl::DisableBrokenType,
+                    weak_factory_.GetWeakPtr(),
+                    type);
+}
+
 void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes(
     syncer::ModelTypeSet disabled_types,
     syncer::ModelTypeSet enabled_types,
     ProfileSyncService* pss) {
   // Autofill sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::AUTOFILL)) {
     pss->RegisterDataTypeController(
-        new AutofillDataTypeController(this, profile_));
+        new AutofillDataTypeController(
+            this, profile_, MakeDisableCallbackFor(syncer::AUTOFILL)));
   }
 
   // Autofill profile sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) {
     pss->RegisterDataTypeController(
-        new AutofillProfileDataTypeController(this, profile_));
+        new AutofillProfileDataTypeController(
+            this, profile_, MakeDisableCallbackFor(syncer::AUTOFILL_PROFILE)));
   }
 
   // Bookmark sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::BOOKMARKS)) {
     pss->RegisterDataTypeController(
         new BookmarkDataTypeController(this, profile_, pss));
   }
 
   // TypedUrl sync is enabled by default.  Register unless explicitly disabled,
   // or if saving history is disabled.
   if (!profile_->GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled) &&
       !disabled_types.Has(syncer::TYPED_URLS)) {
     pss->RegisterDataTypeController(
         new TypedUrlDataTypeController(this, profile_, pss));
   }
 
   // Delete directive sync is enabled by default.  Register unless full history
   // sync is disabled.
   if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES)) {
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::HISTORY_DELETE_DIRECTIVES),
             syncer::HISTORY_DELETE_DIRECTIVES,
             this));
   }
 
   // Session sync is enabled by default.  Register unless explicitly disabled.
   if (!disabled_types.Has(syncer::PROXY_TABS)) {
-    pss->RegisterDataTypeController(new ProxyDataTypeController(
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
-        syncer::PROXY_TABS));
+      pss->RegisterDataTypeController(new ProxyDataTypeController(
+         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+         syncer::PROXY_TABS));
     pss->RegisterDataTypeController(
-        new SessionDataTypeController(this,
-                                      profile_,
-                                      pss->GetSyncedWindowDelegatesGetter(),
-                                      pss->GetLocalDeviceInfoProvider()));
+        new SessionDataTypeController(
+            this,
+            profile_,
+            pss->GetSyncedWindowDelegatesGetter(),
+            pss->GetLocalDeviceInfoProvider(),
+            MakeDisableCallbackFor(syncer::SESSIONS)));
   }
 
   // Favicon sync is enabled by default. Register unless explicitly disabled.
   if (!disabled_types.Has(syncer::FAVICON_IMAGES) &&
       !disabled_types.Has(syncer::FAVICON_TRACKING)) {
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::FAVICON_IMAGES),
             syncer::FAVICON_IMAGES,
             this));
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::FAVICON_TRACKING),
             syncer::FAVICON_TRACKING,
             this));
   }
 
   // Password sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::PASSWORDS)) {
     pss->RegisterDataTypeController(
-        new PasswordDataTypeController(this, profile_));
+        new PasswordDataTypeController(
+            this, profile_, MakeDisableCallbackFor(syncer::PASSWORDS)));
   }
 
   // Article sync is disabled by default.  Register only if explicitly enabled.
   if (IsEnableSyncArticlesSet()) {
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::ARTICLES),
             syncer::ARTICLES,
             this));
   }
 
 #if defined(ENABLE_MANAGED_USERS)
   pss->RegisterDataTypeController(
       new SupervisedUserSyncDataTypeController(
+          MakeDisableCallbackFor(syncer::SUPERVISED_USER_SETTINGS),
           syncer::SUPERVISED_USER_SETTINGS,
           this,
           profile_));
   pss->RegisterDataTypeController(
       new SupervisedUserSyncDataTypeController(
+          MakeDisableCallbackFor(syncer::SUPERVISED_USERS),
           syncer::SUPERVISED_USERS,
           this,
           profile_));
   pss->RegisterDataTypeController(
       new SupervisedUserSyncDataTypeController(
+          MakeDisableCallbackFor(syncer::SUPERVISED_USER_SHARED_SETTINGS),
           syncer::SUPERVISED_USER_SHARED_SETTINGS,
           this,
           profile_));
 #endif
 }
 
 void ProfileSyncComponentsFactoryImpl::RegisterDesktopDataTypes(
     syncer::ModelTypeSet disabled_types,
     syncer::ModelTypeSet enabled_types,
     ProfileSyncService* pss) {
   // App sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::APPS)) {
     pss->RegisterDataTypeController(
-        new ExtensionDataTypeController(syncer::APPS, this, profile_));
+        new ExtensionDataTypeController(syncer::APPS, this, profile_,
+                                        MakeDisableCallbackFor(syncer::APPS)));
   }
 
   // Extension sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::EXTENSIONS)) {
     pss->RegisterDataTypeController(
-        new ExtensionDataTypeController(syncer::EXTENSIONS, this, profile_));
+        new ExtensionDataTypeController(
+            syncer::EXTENSIONS, this, profile_,
+            MakeDisableCallbackFor(syncer::EXTENSIONS)));
   }
 
   // Preference sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::PREFERENCES)) {
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::PREFERENCES),
             syncer::PREFERENCES,
             this));
   }
 
   if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) {
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::PRIORITY_PREFERENCES),
             syncer::PRIORITY_PREFERENCES,
             this));
   }
 
 #if defined(ENABLE_THEMES)
   // Theme sync is enabled by default.  Register unless explicitly disabled.
   if (!disabled_types.Has(syncer::THEMES)) {
     pss->RegisterDataTypeController(
-        new ThemeDataTypeController(this, profile_));
+        new ThemeDataTypeController(this, profile_,
+                                    MakeDisableCallbackFor(syncer::THEMES)));
   }
 #endif
 
   // Search Engine sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::SEARCH_ENGINES)) {
     pss->RegisterDataTypeController(
-        new SearchEngineDataTypeController(this, profile_));
+        new SearchEngineDataTypeController(
+            this, profile_, MakeDisableCallbackFor(syncer::SEARCH_ENGINES)));
   }
 
   // Extension setting sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::EXTENSION_SETTINGS)) {
-    pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
-        syncer::EXTENSION_SETTINGS, this, profile_));
+    pss->RegisterDataTypeController(
+        new ExtensionSettingDataTypeController(
+            syncer::EXTENSION_SETTINGS, this, profile_,
+            MakeDisableCallbackFor(syncer::EXTENSION_SETTINGS)));
   }
 
   // App setting sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::APP_SETTINGS)) {
-    pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
-        syncer::APP_SETTINGS, this, profile_));
+    pss->RegisterDataTypeController(
+        new ExtensionSettingDataTypeController(
+            syncer::APP_SETTINGS, this, profile_,
+            MakeDisableCallbackFor(syncer::APP_SETTINGS)));
   }
 
 #if defined(ENABLE_APP_LIST)
   if (app_list::switches::IsAppListSyncEnabled()) {
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::APP_LIST),
             syncer::APP_LIST,
             this));
   }
 #endif
 
   // Synced Notifications are disabled by default.
 #if defined(ENABLE_EXTENSIONS) && defined(ENABLE_NOTIFICATIONS)
   if (enabled_types.Has(syncer::SYNCED_NOTIFICATIONS)) {
     pss->RegisterDataTypeController(
         new ExtensionBackedDataTypeController(
+              MakeDisableCallbackFor(syncer::SYNCED_NOTIFICATIONS),
               syncer::SYNCED_NOTIFICATIONS,
               "",  // TODO(dewittj): pass the extension hash here.
               this,
               profile_));
 
     pss->RegisterDataTypeController(
         new ExtensionBackedDataTypeController(
+              MakeDisableCallbackFor(syncer::SYNCED_NOTIFICATION_APP_INFO),
               syncer::SYNCED_NOTIFICATION_APP_INFO,
               "",  // TODO(dewittj): pass the extension hash here.
               this,
               profile_));
   }
 #endif
 
 #if defined(OS_LINUX) || defined(OS_WIN) || defined(OS_CHROMEOS)
   // Dictionary sync is enabled by default.
   if (!disabled_types.Has(syncer::DICTIONARY)) {
     pss->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
+            MakeDisableCallbackFor(syncer::DICTIONARY),
             syncer::DICTIONARY,
             this));
   }
 #endif
 }
 
 DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     const DataTypeController::TypeMap* controllers,
@@ skipping 267 matching lines @@
       new TypedUrlModelAssociator(profile_sync_service,
                                   history_backend,
                                   error_handler);
   TypedUrlChangeProcessor* change_processor =
       new TypedUrlChangeProcessor(profile_,
                                   model_associator,
                                   history_backend,
                                   error_handler);
   return SyncComponents(model_associator, change_processor);
 }