Add synchronous and asynchronous methods to ManagedUserSyncService to get the...

Add synchronous and asynchronous methods to ManagedUserSyncService to get the list of managed users.

BUG=none

Review URL: https://chromiumcodereview.appspot.com/23910002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@221486 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/managed_mode/managed_user_sync_service.cc

@@ -5,6 +5,7 @@
 #include "chrome/browser/managed_mode/managed_user_sync_service.h"
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
@@ -121,6 +122,23 @@ void ManagedUserSyncService::DeleteManagedUser(const std::string& id) {
   DCHECK(!sync_error.IsSet());
 }
 
+const DictionaryValue* ManagedUserSyncService::GetManagedUsers() {
+  DCHECK(sync_processor_);
+  return prefs_->GetDictionary(prefs::kManagedUsers);
+}
+
+void ManagedUserSyncService::GetManagedUsersAsync(
+    const ManagedUsersCallback& callback) {
+  // If we are already syncing, just run the callback.
+  if (sync_processor_) {
+    callback.Run(GetManagedUsers());
+    return;
+  }
+
+  // Otherwise queue it up until we start syncing.
+  callbacks_.push_back(callback);
+}
+
 void ManagedUserSyncService::Shutdown() {
   NotifyManagedUsersSyncingStopped();
 }
@@ -184,6 +202,8 @@ SyncMergeResult ManagedUserSyncService::MergeDataAndStartSyncing(
   result.set_num_items_added(num_items_added);
   result.set_num_items_after_association(dict->size());
 
+  DispatchCallbacks();
+
   return result;
 }
 
@@ -287,3 +307,13 @@ void ManagedUserSyncService::NotifyManagedUsersSyncingStopped() {
   FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
                     OnManagedUsersSyncingStopped());
 }
+
+void ManagedUserSyncService::DispatchCallbacks() {
+  const DictionaryValue* managed_users =
+      prefs_->GetDictionary(prefs::kManagedUsers);
+  for (std::vector<ManagedUsersCallback>::iterator it = callbacks_.begin();
+       it != callbacks_.end(); ++it) {
+    it->Run(managed_users);
+  }
+  callbacks_.clear();
+}

chrome/browser/managed_mode/managed_user_sync_service.h

@@ -5,6 +5,9 @@
 #ifndef CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_SYNC_SERVICE_H_
 #define CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_SYNC_SERVICE_H_
 
+#include <vector>
+
+#include "base/callback_forward.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_change_registrar.h"
@@ -13,15 +16,23 @@
 #include "components/browser_context_keyed_service/browser_context_keyed_service.h"
 #include "sync/api/syncable_service.h"
 
-class PrefService;
+namespace base {
+class DictionaryValue;
+}
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
+class PrefService;
+
 class ManagedUserSyncService : public BrowserContextKeyedService,
                                public syncer::SyncableService {
  public:
+  // For use with GetAllManagedUsers() below.
+  typedef base::Callback<void(const base::DictionaryValue*)>
+      ManagedUsersCallback;
+
   virtual ~ManagedUserSyncService();
 
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
@@ -34,6 +45,17 @@ class ManagedUserSyncService : public BrowserContextKeyedService,
                       const std::string& master_key);
   void DeleteManagedUser(const std::string& id);
 
+  // Returns a dictionary containing all managed users managed by this
+  // custodian. This method should only be called once this service has started
+  // syncing managed users (i.e. has finished its initial merge of local and
+  // server-side data, via MergeDataAndStartSyncing), as the stored data might
+  // be outdated before that.
+  const base::DictionaryValue* GetManagedUsers();
+
+  // Calls the passed |callback| with a dictionary containing all managed users
+  // managed by this custodian.
+  void GetManagedUsersAsync(const ManagedUsersCallback& callback);
+
   // BrowserContextKeyedService implementation:
   virtual void Shutdown() OVERRIDE;
 
@@ -62,6 +84,8 @@ class ManagedUserSyncService : public BrowserContextKeyedService,
   void NotifyManagedUserAcknowledged(const std::string& managed_user_id);
   void NotifyManagedUsersSyncingStopped();
 
+  void DispatchCallbacks();
+
   PrefService* prefs_;
   PrefChangeRegistrar pref_change_registrar_;
 
@@ -70,6 +94,8 @@ class ManagedUserSyncService : public BrowserContextKeyedService,
 
   ObserverList<ManagedUserSyncServiceObserver> observers_;
 
+  std::vector<ManagedUsersCallback> callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(ManagedUserSyncService);
 };
 

chrome/browser/managed_mode/managed_user_sync_service_unittest.cc

@@ -64,6 +64,12 @@ SyncChange MockChangeProcessor::GetChange(const std::string& id) const {
   return SyncChange();
 }
 
+// Callback for ManagedUserSyncService::GetManagedUsersAsync().
+void GetManagedUsersCallback(const base::DictionaryValue** dict,
+                             const base::DictionaryValue* managed_users) {
+  *dict = managed_users;
+}
+
 }  // namespace
 
 class ManagedUserSyncServiceTest : public ::testing::Test {
@@ -76,11 +82,6 @@ class ManagedUserSyncServiceTest : public ::testing::Test {
   scoped_ptr<SyncErrorFactory> CreateErrorFactory();
   SyncData CreateRemoteData(const std::string& id, const std::string& name);
 
-  SyncMergeResult StartInitialSync();
-
-  void Acknowledge();
-  void ResetService();
-
   PrefService* prefs() { return profile_.GetPrefs(); }
   ManagedUserSyncService* service() { return service_; }
   MockChangeProcessor* change_processor() { return change_processor_; }
@@ -126,33 +127,23 @@ SyncData ManagedUserSyncServiceTest::CreateRemoteData(
   return SyncData::CreateRemoteData(++sync_data_id_, specifics, base::Time());
 }
 
-SyncMergeResult ManagedUserSyncServiceTest::StartInitialSync() {
-  SyncDataList initial_sync_data;
+TEST_F(ManagedUserSyncServiceTest, MergeEmpty) {
   SyncMergeResult result =
       service()->MergeDataAndStartSyncing(MANAGED_USERS,
-                                          initial_sync_data,
+                                          SyncDataList(),
                                           CreateChangeProcessor(),
                                           CreateErrorFactory());
   EXPECT_FALSE(result.error().IsSet());
-  return result;
-}
-
-void ManagedUserSyncServiceTest::ResetService() {
-  service_->StopSyncing(MANAGED_USERS);
-  service_->Shutdown();
-}
-
-TEST_F(ManagedUserSyncServiceTest, MergeEmpty) {
-  SyncMergeResult result = StartInitialSync();
   EXPECT_EQ(0, result.num_items_added());
   EXPECT_EQ(0, result.num_items_modified());
   EXPECT_EQ(0, result.num_items_deleted());
   EXPECT_EQ(0, result.num_items_before_association());
   EXPECT_EQ(0, result.num_items_after_association());
-  EXPECT_EQ(0u, prefs()->GetDictionary(prefs::kManagedUsers)->size());
+  EXPECT_EQ(0u, service()->GetManagedUsers()->size());
   EXPECT_EQ(0u, change_processor()->changes().size());
 
-  ResetService();
+  service()->StopSyncing(MANAGED_USERS);
+  service()->Shutdown();
 }
 
 TEST_F(ManagedUserSyncServiceTest, MergeExisting) {
@@ -179,6 +170,10 @@ TEST_F(ManagedUserSyncServiceTest, MergeExisting) {
     managed_users->Set(kUserId2, dict);
   }
 
+  const base::DictionaryValue* async_managed_users = NULL;
+  service()->GetManagedUsersAsync(
+      base::Bind(&GetManagedUsersCallback, &async_managed_users));
+
   SyncDataList initial_sync_data;
   initial_sync_data.push_back(CreateRemoteData(kUserId2, kName2));
   initial_sync_data.push_back(CreateRemoteData(kUserId3, kName3));
@@ -196,9 +191,11 @@ TEST_F(ManagedUserSyncServiceTest, MergeExisting) {
   EXPECT_EQ(2, result.num_items_before_association());
   EXPECT_EQ(4, result.num_items_after_association());
 
-  const DictionaryValue* managed_users =
-      prefs()->GetDictionary(prefs::kManagedUsers);
+  const DictionaryValue* managed_users = service()->GetManagedUsers();
   EXPECT_EQ(4u, managed_users->size());
+  EXPECT_TRUE(async_managed_users);
+  EXPECT_TRUE(managed_users->Equals(async_managed_users));
+
   {
     const DictionaryValue* managed_user = NULL;
     ASSERT_TRUE(managed_users->GetDictionary(kUserId2, &managed_user));

chrome/browser/ui/webui/options/browser_options_handler.cc

@@ -31,6 +31,8 @@
 #include "chrome/browser/managed_mode/managed_user_registration_utility.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
+#include "chrome/browser/managed_mode/managed_user_sync_service.h"
+#include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
@@ -1845,9 +1847,9 @@ bool BrowserOptionsHandler::IsValidExistingManagedUserId(
     return false;
   }
 
-  DictionaryPrefUpdate update(Profile::FromWebUI(web_ui())->GetPrefs(),
-                              prefs::kManagedUsers);
-  DictionaryValue* dict = update.Get();
+  Profile* profile = Profile::FromWebUI(web_ui());
+  const DictionaryValue* dict =
+      ManagedUserSyncServiceFactory::GetForProfile(profile)->GetManagedUsers();
   if (!dict->HasKey(existing_managed_user_id))
     return false;
 

chrome/browser/ui/webui/options/managed_user_import_handler.cc

@@ -10,6 +10,8 @@
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/managed_mode/managed_user_sync_service.h"
+#include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
@@ -60,7 +62,7 @@ void ManagedUserImportHandler::RequestExistingManagedUsers(
     managed_user_ids.insert(cache.GetManagedUserIdOfProfileAtIndex(i));
 
   const DictionaryValue* dict =
-      profile->GetPrefs()->GetDictionary(prefs::kManagedUsers);
+      ManagedUserSyncServiceFactory::GetForProfile(profile)->GetManagedUsers();
   ListValue managed_users;
   for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     const DictionaryValue* value = NULL;