SupervisedUserSyncService cleanup: Implement SigninManagerBase::Observer

chrome/browser/supervised_user/legacy/supervised_user_sync_service.cc

 // Copyright 2014 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/supervised_user/legacy/supervised_user_sync_service.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "components/signin/core/browser/signin_manager.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/sync.pb.h"
 
 #if defined(OS_CHROMEOS)
 #include "components/user_manager/user_image/default_user_images.h"
 #endif
@@ skipping 88 matching lines @@
 const char SupervisedUserSyncService::kChromeAvatar[] = "chromeAvatar";
 const char SupervisedUserSyncService::kChromeOsAvatar[] = "chromeOsAvatar";
 const char SupervisedUserSyncService::kMasterKey[] = "masterKey";
 const char SupervisedUserSyncService::kName[] = "name";
 const char SupervisedUserSyncService::kPasswordSignatureKey[] =
     "passwordSignatureKey";
 const char SupervisedUserSyncService::kPasswordEncryptionKey[] =
     "passwordEncryptionKey";
 const int SupervisedUserSyncService::kNoAvatar = -100;
 
-SupervisedUserSyncService::SupervisedUserSyncService(PrefService* prefs)
-    : prefs_(prefs) {
-  pref_change_registrar_.Init(prefs_);
-  pref_change_registrar_.Add(
-      prefs::kGoogleServicesLastUsername,
-      base::Bind(&SupervisedUserSyncService::OnLastSignedInUsernameChange,
-                 base::Unretained(this)));
+SupervisedUserSyncService::SupervisedUserSyncService(Profile* profile)
+    : profile_(profile), prefs_(profile->GetPrefs()) {
+  SigninManagerFactory::GetForProfile(profile_)->AddObserver(this);
 }
 
 SupervisedUserSyncService::~SupervisedUserSyncService() {
 }
 
 // static
 void SupervisedUserSyncService::RegisterProfilePrefs(
     PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kSupervisedUsers,
                                    PrefRegistrySyncable::UNSYNCABLE_PREF);
@@ skipping 249 matching lines @@
     callback.Run(GetSupervisedUsers());
     return;
   }
 
   // Otherwise queue it up until we start syncing.
   callbacks_.push_back(callback);
 }
 
 void SupervisedUserSyncService::Shutdown() {
   NotifySupervisedUsersSyncingStopped();
+  SigninManagerFactory::GetForProfile(profile_)->RemoveObserver(this);
 }
 
 SyncMergeResult SupervisedUserSyncService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     scoped_ptr<SyncChangeProcessor> sync_processor,
     scoped_ptr<SyncErrorFactory> error_handler) {
   DCHECK_EQ(SUPERVISED_USERS, type);
   sync_processor_ = sync_processor.Pass();
   error_handler_ = error_handler.Pass();
@@ skipping 122 matching lines @@
       }
       case SyncChange::ACTION_INVALID: {
         NOTREACHED();
         break;
       }
     }
   }
   return error;
 }
 
-void SupervisedUserSyncService::OnLastSignedInUsernameChange() {
+void SupervisedUserSyncService::GoogleSignedOut(
+    const std::string& account_id,
+    const std::string& username) {
   DCHECK(!sync_processor_);
 
-  // If the last signed in user changes, we clear all data, to avoid supervised
+  // When the signed in user changes, we clear all data, to avoid supervised

[Bernhard Bauer, 2015/03/23 15:50:01]

"Clear all data on signout, [...]"?

[Marc Treib, 2015/03/23 16:03:05]

Ah, forgot to update the comment. Done, thanks!

   // users from one custodian appearing in another one's profile.
   prefs_->ClearPref(prefs::kSupervisedUsers);
 }
 
 void SupervisedUserSyncService::NotifySupervisedUserAcknowledged(
     const std::string& supervised_user_id) {
   FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver, observers_,
                     OnSupervisedUserAcknowledged(supervised_user_id));
 }
 
 void SupervisedUserSyncService::NotifySupervisedUsersSyncingStopped() {
   FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver, observers_,
                     OnSupervisedUsersSyncingStopped());
 }
 
 void SupervisedUserSyncService::NotifySupervisedUsersChanged() {
   FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver,
                     observers_,
                     OnSupervisedUsersChanged());
 }
 
 void SupervisedUserSyncService::DispatchCallbacks() {
   const base::DictionaryValue* supervised_users =
       prefs_->GetDictionary(prefs::kSupervisedUsers);
   for (const auto& callback : callbacks_)
     callback.Run(supervised_users);
   callbacks_.clear();
 }