Collect the custodian's full name when a supervised user is created.

chrome/browser/managed_mode/managed_user_registration_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_REGISTRATION_SERVICE_H_
 #define CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_REGISTRATION_SERVICE_H_
 
 #include <map>
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/strings/string16.h"
 #include "base/timer.h"
+#include "chrome/browser/profiles/profile_downloader.h"
+#include "chrome/browser/profiles/profile_downloader_delegate.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "components/browser_context_keyed_service/browser_context_keyed_service.h"
 #include "sync/api/syncable_service.h"
 
 class GoogleServiceAuthError;
 class ManagedUserRefreshTokenFetcher;
 class PrefService;
 
 namespace browser_sync {
 class DeviceInfo;
 }
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 // Structure to store registration information.
 struct ManagedUserRegistrationInfo {
   explicit ManagedUserRegistrationInfo(const string16& name);
   string16 name;
   std::string master_key;
 };
 
 // Holds the state necessary for registering a new managed user with the
 // management server and associating it with its custodian. It is owned by the
 // custodian's profile.
 class ManagedUserRegistrationService : public BrowserContextKeyedService,
-                                       public syncer::SyncableService {
+                                       public syncer::SyncableService,
+                                       public ProfileDownloaderDelegate {
  public:
   // Callback for Register() below. If registration is successful, |token| will
   // contain an OAuth2 refresh token for the newly registered managed user,
   // otherwise |token| will be empty and |error| will contain the authentication
   // error for the custodian.
   typedef base::Callback<void(const GoogleServiceAuthError& /* error */,
                               const std::string& /* token */)>
       RegistrationCallback;
 
+  // Callback for DownloadProfile() below. If the GAIA profile download is
+  // successful, the profile's full (display) name will be returned.
+  typedef base::Callback<void(const string16& /* full name */)>
+      DownloadProfileCallback;
+
   ManagedUserRegistrationService(
       PrefService* prefs,
       scoped_ptr<ManagedUserRefreshTokenFetcher> token_fetcher);
   virtual ~ManagedUserRegistrationService();
 
+  // ProfileDownloaderDelegate:
+  virtual bool NeedsProfilePicture() const OVERRIDE;
+  virtual int GetDesiredImageSideLength() const OVERRIDE;
+  virtual std::string GetCachedPictureURL() const OVERRIDE;
+  virtual Profile* GetBrowserProfile() OVERRIDE;
+  virtual void OnProfileDownloadSuccess(ProfileDownloader* downloader) OVERRIDE;
+  virtual void OnProfileDownloadFailure(
+      ProfileDownloader* downloader,
+      ProfileDownloaderDelegate::FailureReason reason) OVERRIDE;
+
   static void RegisterUserPrefs(user_prefs::PrefRegistrySyncable* registry);
 
   // Registers a new managed user with the server. |info| contains necessary
   // information like the display name of the  the user. |callback| is called
   // with the result of the registration. We use the info here and not the
   // profile, because on Chrome OS the profile of the managed user does
   // not yet exist.
   void Register(const ManagedUserRegistrationInfo& info,
                 const RegistrationCallback& callback);
 
+  // Downloads the GAIA account information for the |profile|. If the download
+  // is successful, the profile's full (display) name will be returned via the
+  // callback. If the download fails or never completes, the callback will
+  // not be called.
+  void DownloadProfile(Profile* profile,

[Bernhard Bauer, 2013/06/21 15:52:07]

It's a bit weird that we have to pass in the profile here, but for now I think
it's okay. Eventually we should probably integrate this with
GAIAInfoUpdateService.

[Pam (message me for reviews), 2013/06/21 16:19:09]

Yeah, I don't know why the downloader doesn't take a profile as a parameter into
Start(), but I didn't want to get into refactoring its whole API here.

GAIAInfoUpdateService uses the same downloader, of course, and fills the
ProfileInfoCache. If the GAIAInfoUpdateService is ever enabled, this can all
come out and we can grab what we need from the ProfileInfoCache instead. There's
a TODO in here about that, but I'll make it more clear.

+                       const DownloadProfileCallback& callback);
+
   // Cancels any registration currently in progress, without calling the
   // callback or reporting an error. This should be called when the user
   // actively cancels the registration by canceling profile creation.
   void CancelPendingRegistration();
 
   // ProfileKeyedService implementation:
   virtual void Shutdown() OVERRIDE;
 
   // SyncableService implementation:
   virtual syncer::SyncMergeResult MergeDataAndStartSyncing(
@@ skipping 29 matching lines @@
   // calls the callback specified in Register() with the given |error|.
   void AbortPendingRegistration(bool run_callback,
                                 const GoogleServiceAuthError& error);
 
   // If |run_callback| is true, dispatches the callback with the saved token
   // (which may be empty) and the given |error|. In any case, resets internal
   // variables to be ready for the next registration.
   void CompleteRegistration(bool run_callback,
                             const GoogleServiceAuthError& error);
 
+  void OnProfileDownloadComplete();
+
   base::WeakPtrFactory<ManagedUserRegistrationService> weak_ptr_factory_;
   PrefService* prefs_;
   PrefChangeRegistrar pref_change_registrar_;
   scoped_ptr<ManagedUserRefreshTokenFetcher> token_fetcher_;
 
   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
   scoped_ptr<syncer::SyncErrorFactory> error_handler_;
 
   // Provides a timeout during profile creation.
   base::OneShotTimer<ManagedUserRegistrationService> registration_timer_;
 
   std::string pending_managed_user_id_;
   std::string pending_managed_user_token_;
   bool pending_managed_user_acknowledged_;
   RegistrationCallback callback_;
 
+  Profile* download_profile_;
+  scoped_ptr<ProfileDownloader> profile_downloader_;
+  DownloadProfileCallback download_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(ManagedUserRegistrationService);
 };
 
 #endif  // CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_REGISTRATION_SERVICE_H_