sync: Make ProfileSyncService a ProfileKeyedService.

chrome/browser/sync/profile_sync_service.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 19 matching lines @@
 #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/glue/session_data_type_controller.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
 #include "chrome/browser/sync/internal_api/configure_reason.h"
 #include "chrome/browser/sync/internal_api/sync_manager.h"
 #include "chrome/browser/sync/js/js_arg_list.h"
 #include "chrome/browser/sync/js/js_event_details.h"
-#include "chrome/browser/sync/profile_sync_components_factory.h"
+#include "chrome/browser/sync/profile_sync_components_factory_impl.h"
 #include "chrome/browser/sync/signin_manager.h"
 #include "chrome/browser/sync/sync_global_error.h"
 #include "chrome/browser/sync/util/cryptographer.h"
 #include "chrome/browser/sync/util/oauth.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/global_error_service.h"
 #include "chrome/browser/ui/global_error_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 80 matching lines @@
   // sync servers. Users with officially-branded Chrome stable and beta builds
   // will go to the standard sync servers.
   //
   // GetChannel hits the registry on Windows. See http://crbug.com/70380.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     sync_service_url_ = GURL(kSyncServerUrl);
   }
-
 }
 
 ProfileSyncService::~ProfileSyncService() {
   sync_prefs_.RemoveSyncPrefObserver(this);
-  Shutdown(false);
+  Shutdown();
 }
 
 bool ProfileSyncService::AreCredentialsAvailable() {
   return AreCredentialsAvailable(false);
 }
 
 bool ProfileSyncService::AreCredentialsAvailable(
     bool check_oauth_login_token) {
   if (IsManaged()) {
     return false;
@@ skipping 212 matching lines @@
   InitializeBackend(!HasSyncSetupCompleted());
 
   if (!sync_global_error_.get()) {
     sync_global_error_.reset(new SyncGlobalError(this));
     GlobalErrorServiceFactory::GetForProfile(profile_)->AddGlobalError(
         sync_global_error_.get());
     AddObserver(sync_global_error_.get());
   }
 }
 
-void ProfileSyncService::Shutdown(bool sync_disabled) {
+void ProfileSyncService::Shutdown() {
+  ShutdownImpl(false);
+}
+
+void ProfileSyncService::ShutdownImpl(bool sync_disabled) {
   // First, we spin down the backend and wait for it to stop syncing completely
   // before we Stop the data type manager.  This is to avoid a late sync cycle
   // applying changes to the sync db that wouldn't get applied via
   // ChangeProcessors, leading to back-from-the-dead bugs.
   if (backend_.get())
     backend_->StopSyncingForShutdown();
 
   // Stop all data type controllers, if needed.  Note that until Stop
   // completes, it is possible in theory to have a ChangeProcessor apply a
   // change from a native model.  In that case, it will get applied to the sync
@@ skipping 63 matching lines @@
 }
 
 void ProfileSyncService::DisableForUser() {
   if (SetupInProgress())
     wizard_.Step(SyncSetupWizard::ABORT);
 
   // Clear prefs (including SyncSetupHasCompleted) before shutting down so
   // PSS clients don't think we're set up while we're shutting down.
   sync_prefs_.ClearPreferences();
   ClearUnrecoverableError();
-  Shutdown(true);
+  ShutdownImpl(true);
 
   signin_->SignOut();
 
   NotifyObservers();
 }
 
 bool ProfileSyncService::HasSyncSetupCompleted() const {
   return sync_prefs_.HasSyncSetupCompleted();
 }
 
@@ skipping 37 matching lines @@
   NOTREACHED();
   return "";
 }
 
 void ProfileSyncService::RegisterNewDataType(syncable::ModelType data_type) {
   if (data_type_controllers_.count(data_type) > 0)
     return;
   switch (data_type) {
     case syncable::SESSIONS:
       RegisterDataTypeController(
-          new browser_sync::SessionDataTypeController(factory_,
+          new browser_sync::SessionDataTypeController(factory_.get(),
                                                       profile_,
                                                       this));
       return;
     case syncable::TYPED_URLS:
-      RegisterDataTypeController(
-          new browser_sync::TypedUrlDataTypeController(factory_,
+          new browser_sync::TypedUrlDataTypeController(factory_.get(),
                                                        profile_,
-                                                       this));
+                                                       this);
       return;
     default:
       break;
   }
   NOTREACHED();
 }
 
 // An invariant has been violated.  Transition to an error state where we try
 // to do as little work as possible, to avoid further corruption or crashes.
 void ProfileSyncService::OnUnrecoverableError(
     const tracked_objects::Location& from_here,
     const std::string& message) {
   unrecoverable_error_detected_ = true;
   unrecoverable_error_message_ = message;
   unrecoverable_error_location_ = from_here;
 
   // Tell the wizard so it can inform the user only if it is already open.
   wizard_.Step(SyncSetupWizard::FATAL_ERROR);
 
   NotifyObservers();
   std::string location;
   from_here.Write(true, true, &location);
   LOG(ERROR)
       << "Unrecoverable error detected at " << location
       << " -- ProfileSyncService unusable: " << message;
 
   // Shut all data types down.
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&ProfileSyncService::Shutdown, weak_factory_.GetWeakPtr(),
+      base::Bind(&ProfileSyncService::ShutdownImpl, weak_factory_.GetWeakPtr(),
                  true));
 }
 
 void ProfileSyncService::OnBackendInitialized(
     const WeakHandle<JsBackend>& js_backend, bool success) {
   if (!HasSyncSetupCompleted()) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
@@ skipping 955 matching lines @@
     return false;
 
   if (!data_type_manager_.get())
     return false;
 
   return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }
 
 void ProfileSyncService::StopAndSuppress() {
   sync_prefs_.SetStartSuppressed(true);
-  Shutdown(false);
+  ShutdownImpl(false);
 }
 
 void ProfileSyncService::UnsuppressAndStart() {
   DCHECK(profile_);
   sync_prefs_.SetStartSuppressed(false);
   // Set username in SigninManager, as SigninManager::OnGetUserInfoSuccess
   // is never called for some clients.
   if (signin_->GetAuthenticatedUsername().empty()) {
     signin_->SetAuthenticatedUsername(
         sync_prefs_.GetGoogleServicesUsername());
@@ skipping 23 matching lines @@
              << "Unrecoverable error.";
   } else {
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 const FailedDatatypesHandler& ProfileSyncService::failed_datatypes_handler() {
   return failed_datatypes_handler_;
 }