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

chrome/browser/managed_mode/managed_user_sync_service.cc

 // Copyright 2013 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/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"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.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"
@@ skipping 96 matching lines @@
   SyncChangeList change_list;
   change_list.push_back(SyncChange(
       FROM_HERE,
       SyncChange::ACTION_DELETE,
       SyncData::CreateLocalDelete(id, MANAGED_USERS)));
   SyncError sync_error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   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();
 }
 
 SyncMergeResult ManagedUserSyncService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     scoped_ptr<SyncChangeProcessor> sync_processor,
     scoped_ptr<SyncErrorFactory> error_handler) {
   DCHECK_EQ(MANAGED_USERS, type);
@@ skipping 43 matching lines @@
     change_list.push_back(
         SyncChange(FROM_HERE, SyncChange::ACTION_ADD,
             CreateLocalSyncData(it.key(), name, acknowledged, master_key)));
   }
   result.set_error(sync_processor_->ProcessSyncChanges(FROM_HERE, change_list));
 
   result.set_num_items_modified(num_items_modified);
   result.set_num_items_added(num_items_added);
   result.set_num_items_after_association(dict->size());
 
+  DispatchCallbacks();
+
   return result;
 }
 
 void ManagedUserSyncService::StopSyncing(ModelType type) {
   DCHECK_EQ(MANAGED_USERS, type);
   // The observers may want to change the Sync data, so notify them before
   // resetting the |sync_processor_|.
   NotifyManagedUsersSyncingStopped();
   sync_processor_.reset();
   error_handler_.reset();
@@ skipping 83 matching lines @@
 void ManagedUserSyncService::NotifyManagedUserAcknowledged(
     const std::string& managed_user_id) {
   FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
                     OnManagedUserAcknowledged(managed_user_id));
 }
 
 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();
+}