Rewrite DTM to support dynamic data type configuration

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2006-2008 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/sync/profile_sync_service.h"
 
+#include <set>
+
 #include "app/l10n_util.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_manager.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/notification_details.h"
+#include "chrome/common/notification_service.h"
+#include "chrome/common/notification_source.h"
+#include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "grit/generated_resources.h"
 #include "net/base/cookie_monster.h"
 #include "views/window/window.h"
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
 
 typedef GoogleServiceAuthError AuthError;
 
 // Default sync server URL.
 static const char kSyncServerUrl[] = "https://clients4.google.com/chrome-sync";
 
 ProfileSyncService::ProfileSyncService(ProfileSyncFactory* factory,
                                        Profile* profile,
                                        bool bootstrap_sync_authentication)
     : last_auth_error_(AuthError::None()),
       factory_(factory),
       profile_(profile),
       bootstrap_sync_authentication_(bootstrap_sync_authentication),
       sync_service_url_(kSyncServerUrl),
       backend_initialized_(false),
       expecting_first_run_auth_needed_event_(false),
       is_auth_in_progress_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(wizard_(this)),
       unrecoverable_error_detected_(false),
-      startup_had_first_time_(false),
       notification_method_(browser_sync::kDefaultNotificationMethod) {
+  registrar_.Add(this,
+                 NotificationType::SYNC_CONFIGURE_START,
+                 NotificationService::AllSources());
+  registrar_.Add(this,
+                 NotificationType::SYNC_CONFIGURE_DONE,
+                 NotificationService::AllSources());
 }
 
 ProfileSyncService::~ProfileSyncService() {
   Shutdown(false);
 }
 
 void ProfileSyncService::Initialize() {
   InitSettings();
   RegisterPreferences();
 
@@ skipping 10 matching lines @@
       StartUp();
       profile()->GetPrefs()->SetBoolean(prefs::kSyncBootstrappedAuth, true);
     }
   } else {
     StartUp();
   }
 }
 
 void ProfileSyncService::RegisterDataTypeController(
     DataTypeController* data_type_controller) {
-  DCHECK(data_type_controllers_.count(data_type_controller->type()) == 0);
+  DCHECK_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
   data_type_controllers_[data_type_controller->type()] =
       data_type_controller;
 }
 
 void ProfileSyncService::InitSettings() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   // Override the sync server URL from the command-line, if sync server
   // command-line argument exists.
   if (command_line.HasSwitch(switches::kSyncServiceURL)) {
@@ skipping 300 matching lines @@
     // A sync dialog was aborted before authentication or merge acceptance.
     // Rollback.
     DisableForUser();
   }
 
   FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
 }
 
 void ProfileSyncService::StartProcessingChangesIfReady() {
   DCHECK(backend_initialized_);
-  startup_had_first_time_ = false;
 
   // If we're running inside Chromium OS, always allow merges and
   // consider the sync setup complete.
   if (bootstrap_sync_authentication_) {
     SetSyncSetupCompleted();
   }
 
+  std::set<syncable::ModelType> types;
+  for (DataTypeController::TypeMap::const_iterator it =
+           data_type_controllers_.begin();
+       it != data_type_controllers_.end(); ++it) {
+    types.insert((*it).first);
+  }
+
   data_type_manager_.reset(
       factory_->CreateDataTypeManager(backend_.get(), data_type_controllers_));
-  data_type_manager_->Start(
-      NewCallback(this, &ProfileSyncService::DataTypeManagerStartCallback));
-}
-
-void ProfileSyncService::DataTypeManagerStartCallback(
-    DataTypeManager::StartResult result) {
-  if (result != DataTypeManager::OK) {
-    OnUnrecoverableError();
-    return;
-  }
-
-  wizard_.Step(SyncSetupWizard::DONE);
-  FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
+  data_type_manager_->Configure(types);
 }
 
 void ProfileSyncService::ActivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   change_processor->Start(profile(), backend_->GetUserShareHandle());
   backend_->ActivateDataType(data_type_controller, change_processor);
 }
 
 void ProfileSyncService::DeactivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   change_processor->Stop();
   backend_->DeactivateDataType(data_type_controller, change_processor);
 }
 
+void ProfileSyncService::Observe(NotificationType type,
+                                 const NotificationSource& source,
+                                 const NotificationDetails& details) {
+  switch (type.value) {
+    case NotificationType::SYNC_CONFIGURE_START: {
+      // TODO(sync): Maybe toast?
+      break;
+    }
+    case NotificationType::SYNC_CONFIGURE_DONE: {
+      DataTypeManager::ConfigureResult result =
+          *(Details<DataTypeManager::ConfigureResult>(details).ptr());
+      if (result != DataTypeManager::OK) {
+        OnUnrecoverableError();
+        return;
+      }
+
+      // TODO(sync): Less wizard, more toast.
+      wizard_.Step(SyncSetupWizard::DONE);
+      FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
+      break;
+    }
+    default: {
+      NOTREACHED();
+    }
+  }
+}
+
 void ProfileSyncService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ProfileSyncService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ProfileSyncService::SyncEvent(SyncEventCodes code) {
   UMA_HISTOGRAM_ENUMERATION("Sync.EventCodes", code, MAX_SYNC_EVENT_CODE);
 }
 
 bool ProfileSyncService::IsSyncEnabled() {
   // We have switches::kEnableSync just in case we need to change back to
   // sync-disabled-by-default on a platform.
   return !CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableSync);
 }
 
 bool ProfileSyncService::ShouldPushChanges() {
   // True only after all bootstrapping has succeeded: the sync backend
   // is initialized, all enabled data types are consistent with one
   // another, and no unrecoverable error has transpired.
   if (unrecoverable_error_detected_)
     return false;
 
   if (!data_type_manager_.get())
     return false;
 
-  return data_type_manager_->state() == DataTypeManager::STARTED;
+  return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }