Reland 203015 "Add ManagedUserTokenFetcher to fetch scoped-down ..."

chrome/browser/managed_mode/managed_user_registration_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_registration_service.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/managed_mode/managed_user_refresh_token_fetcher.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/sync/glue/device_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
+#include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/sync.pb.h"
 
 using base::DictionaryValue;
 using syncer::MANAGED_USERS;
 using syncer::ModelType;
 using syncer::SyncChange;
 using syncer::SyncChangeList;
@@ skipping 18 matching lines @@
   specifics.mutable_managed_user()->set_id(id);
   specifics.mutable_managed_user()->set_name(name);
   if (acknowledged)
     specifics.mutable_managed_user()->set_acknowledged(true);
   return SyncData::CreateLocalData(id, name, specifics);
 }
 
 }  // namespace
 
 ManagedUserRegistrationService::ManagedUserRegistrationService(
-    PrefService* prefs)
+    PrefService* prefs,
+    scoped_ptr<ManagedUserRefreshTokenFetcher> token_fetcher)
     : weak_ptr_factory_(this),
       prefs_(prefs),
+      token_fetcher_(token_fetcher.Pass()),
       pending_managed_user_acknowledged_(false) {
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(
       prefs::kGoogleServicesLastUsername,
       base::Bind(&ManagedUserRegistrationService::OnLastSignedInUsernameChange,
                  base::Unretained(this)));
 }
 
 ManagedUserRegistrationService::~ManagedUserRegistrationService() {
   DCHECK(pending_managed_user_id_.empty());
@@ skipping 28 matching lines @@
         FROM_HERE,
         SyncChange::ACTION_ADD,
         CreateLocalSyncData(
             pending_managed_user_id_, base::UTF16ToUTF8(name), false)));
     SyncError error =
         sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
     DCHECK(!error.IsSet()) << error.ToString();
   }
 
   callback_ = callback;
-  OnReceivedToken("abcdef");  // TODO(bauerb): This is a stub implementation.
+  browser_sync::DeviceInfo::CreateLocalDeviceInfo(
+      base::Bind(&ManagedUserRegistrationService::FetchToken,
+                 weak_ptr_factory_.GetWeakPtr(), name));
 }
 
 ProfileManager::CreateCallback
 ManagedUserRegistrationService::GetRegistrationAndInitCallback() {
   return base::Bind(&ManagedUserRegistrationService::OnProfileCreated,
                     weak_ptr_factory_.GetWeakPtr());
 }
 
 void ManagedUserRegistrationService::Shutdown() {
   CancelPendingRegistration();
@@ skipping 144 matching lines @@
 }
 
 void ManagedUserRegistrationService::OnManagedUserAcknowledged(
     const std::string& managed_user_id) {
   DCHECK_EQ(pending_managed_user_id_, managed_user_id);
   DCHECK(!pending_managed_user_acknowledged_);
   pending_managed_user_acknowledged_ = true;
   DispatchCallbackIfReady();
 }
 
-void ManagedUserRegistrationService::OnReceivedToken(const std::string& token) {
-  DCHECK(pending_managed_user_token_.empty());
+void ManagedUserRegistrationService::FetchToken(
+    const string16& name,
+    const browser_sync::DeviceInfo& device_info) {
+  token_fetcher_->Start(
+      pending_managed_user_id_, name, device_info.client_name(),
+      base::Bind(&ManagedUserRegistrationService::OnReceivedToken,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void ManagedUserRegistrationService::OnReceivedToken(
+    const GoogleServiceAuthError& error,
+    const std::string& token) {
+  if (error.state() != GoogleServiceAuthError::NONE) {
+    DispatchCallback(error);
+    return;
+  }
+
+  DCHECK(!token.empty());
   pending_managed_user_token_ = token;
   DispatchCallbackIfReady();
 }
 
 void ManagedUserRegistrationService::DispatchCallbackIfReady() {
   if (!pending_managed_user_acknowledged_ ||
       pending_managed_user_token_.empty()) {
     return;
   }
 
@@ skipping 33 matching lines @@
   // disk, and once after all the profile services (including the
   // ManagedUserService) have been initialized. Ignore the first one.
   if (status != Profile::CREATE_STATUS_INITIALIZED)
     return;
 
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile);
   DCHECK(managed_user_service->ProfileIsManaged());
   managed_user_service->RegisterAndInitSync(this);
 }