Setup Sync to use OAuth token for managed users.

chrome/browser/managed_mode/managed_user_service.cc

 // Copyright (c) 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_service.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
@@ skipping 121 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ManagedModeURLFilter::SetManualURLs,
                  io_url_filter_, base::Owned(url_map.release())));
 }
 
 ManagedUserService::ManagedUserService(Profile* profile)
     : weak_ptr_factory_(this),
       profile_(profile),
-      elevated_for_testing_(false) {}
+      waiting_for_sync_initialization_(false),
+      elevated_for_testing_(false) {
+}
 
 ManagedUserService::~ManagedUserService() {}
 
+void ManagedUserService::Shutdown() {
+  ProfileSyncService* sync_service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+  if (sync_service)
+    sync_service->RemoveObserver(this);
+}
+
 bool ManagedUserService::ProfileIsManaged() const {
   return ProfileIsManaged(profile_);
 }
 
 // static
 bool ManagedUserService::ProfileIsManaged(Profile* profile) {
   return profile->GetPrefs()->GetBoolean(prefs::kProfileIsManaged);
 }
 
 // static
@@ skipping 106 matching lines @@
 }
 
 bool ManagedUserService::UserMayModifySettings(
     const extensions::Extension* extension,
     string16* error) const {
   // |extension| can be NULL in unit tests.
   return ExtensionManagementPolicyImpl(
       extension ? extension->id() : std::string(), error);
 }
 
+void ManagedUserService::OnStateChanged() {
+  ProfileSyncService* service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+  if (waiting_for_sync_initialization_ && service->sync_initialized()) {
+    SetupSync();
+    service->RemoveObserver(this);
+    waiting_for_sync_initialization_ = false;
+    return;
+  }
+
+  DLOG_IF(ERROR, service->GetAuthError().state() ==
+                     GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS)
+      << "Credentials rejected";
+}
+
 void ManagedUserService::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       const extensions::Extension* extension =
           content::Details<extensions::Extension>(details).ptr();
       if (!extensions::ManagedModeInfo::GetContentPackSiteList(
               extension).empty()) {
         UpdateSiteLists();
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const extensions::UnloadedExtensionInfo* extension_info =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       if (!extensions::ManagedModeInfo::GetContentPackSiteList(
               extension_info->extension).empty()) {
         UpdateSiteLists();
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
+void ManagedUserService::SetupSync() {
+  ProfileSyncService* service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+  DCHECK(service->sync_initialized());
+
+  bool sync_everything = false;
+  syncer::ModelTypeSet synced_datatypes;
+  synced_datatypes.Put(syncer::MANAGED_USER_SETTINGS);
+  service->OnUserChoseDatatypes(sync_everything, synced_datatypes);
+
+  // Notify ProfileSyncService that we are done with configuration.
+  service->SetSetupInProgress(false);
+  service->SetSyncSetupCompleted();
+}
+
 bool ManagedUserService::ExtensionManagementPolicyImpl(
     const std::string& extension_id,
     string16* error) const {
   if (!ProfileIsManaged())
     return true;
 
   if (elevated_for_testing_)
     return true;
 
   if (error)
@@ skipping 97 matching lines @@
       urls->push_back(url);
   }
 }
 
 void ManagedUserService::InitForTesting() {
   DCHECK(!profile_->GetPrefs()->GetBoolean(prefs::kProfileIsManaged));
   profile_->GetPrefs()->SetBoolean(prefs::kProfileIsManaged, true);
   Init();
 }
 
-void ManagedUserService::InitSync(const std::string& sync_token) {
+void ManagedUserService::InitSync(const std::string& refresh_token) {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
-  DCHECK(!service->sync_initialized());
   // Tell the sync service that setup is in progress so we don't start syncing
   // until we've finished configuration.
   service->SetSetupInProgress(true);
 
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
-  token_service->AddAuthTokenManually(GaiaConstants::kSyncService, sync_token);
+  token_service->UpdateCredentialsWithOAuth2(
+      GaiaAuthConsumer::ClientOAuthResult(refresh_token, std::string(), 0));
 
-  bool sync_everything = false;
-  syncer::ModelTypeSet synced_datatypes;
-  synced_datatypes.Put(syncer::MANAGED_USER_SETTINGS);
-  service->OnUserChoseDatatypes(sync_everything, synced_datatypes);
-
-  // Notify ProfileSyncService that we are done with configuration.
-  service->SetSetupInProgress(false);
-  service->SetSyncSetupCompleted();
+  // Continue in SetupSync() once the Sync backend has been initialized.
+  if (service->sync_initialized()) {
+    SetupSync();
+  } else {
+    ProfileSyncServiceFactory::GetForProfile(profile_)->AddObserver(this);
+    waiting_for_sync_initialization_ = true;
+  }
 }
 
 // static
 const char* ManagedUserService::GetManagedUserPseudoEmail() {
   return kManagedUserPseudoEmail;
 }
 
 void ManagedUserService::Init() {
   ManagedModePolicyProvider* policy_provider = GetPolicyProvider();
   if (!ProfileIsManaged()) {
     if (policy_provider)
       policy_provider->Clear();
 
     return;
   }
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kManagedUserSyncToken)) {
     InitSync(
         command_line->GetSwitchValueASCII(switches::kManagedUserSyncToken));
   }
 
+  // TokenService only loads tokens automatically if we're signed in, so we have
+  // to nudge it ourselves.
+  TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
+  token_service->LoadTokensFromDB();
+
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile_);
   extensions::ManagementPolicy* management_policy =
       extension_system->management_policy();
   if (management_policy)
     extension_system->management_policy()->RegisterProvider(this);
 
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
@@ skipping 74 matching lines @@
       profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
   scoped_ptr<std::map<GURL, bool> > url_map(new std::map<GURL, bool>());
   for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     bool allow = false;
     bool result = it.value().GetAsBoolean(&allow);
     DCHECK(result);
     (*url_map)[GURL(it.key())] = allow;
   }
   url_filter_context_.SetManualURLs(url_map.Pass());
 }