Setup Sync to use OAuth token for managed users.

chrome/browser/policy/cloud/user_policy_signin_service.cc

 // Copyright (c) 2012 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/policy/cloud/user_policy_signin_service.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
@@ skipping 14 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/oauth2_access_token_consumer.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher.h"
 
+#if defined(ENABLE_MANAGED_USERS)
+#include "chrome/browser/managed_mode/managed_user_service.h"
+#endif
+
 namespace em = enterprise_management;
 
 namespace {
 
 const char kServiceScopeGetUserInfo[] =
     "https://www.googleapis.com/auth/userinfo.email";
 
 // The key under which the hosted-domain value is stored in the UserInfo
 // response.
 const char kGetHostedDomainKey[] = "hd";
@@ skipping 176 matching lines @@
   DCHECK_EQ(client, client_);
   RequestCompleted();
 }
 
 UserPolicySigninService::UserPolicySigninService(
     Profile* profile)
     : profile_(profile),
       weak_factory_(this) {
   if (profile_->GetPrefs()->GetBoolean(prefs::kDisableCloudPolicyOnSignin))
     return;
 

[Joao da Silva, 2013/06/12 19:56:13]

Really, the check should be here :-) Note the check right above, it's meant for
a similar purpose and they should be together.

[Bernhard Bauer, 2013/06/13 09:45:05]

Urr, yes, sorry. I didn't pay much attention and mixed up the return above here
with the one below.

   // Initialize/shutdown the UserCloudPolicyManager when the user signs out.
   registrar_.Add(this,
                  chrome::NOTIFICATION_GOOGLE_SIGNED_OUT,
                  content::Source<Profile>(profile));
 
   // Listen for an OAuth token to become available so we can register a client
   // if for some reason the client is not already registered (for example, if
   // the policy load failed during initial signin).
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_AVAILABLE,
@@ skipping 122 matching lines @@
     return;
   }
 
   // If using a TestingProfile with no SigninManager or UserCloudPolicyManager,
   // skip initialization.
   if (!GetManager() || !SigninManagerFactory::GetForProfile(profile_)) {
     DVLOG(1) << "Skipping initialization for tests due to missing components.";
     return;
   }
 
+#if defined(ENABLE_MANAGED_USERS)
+  if (ManagedUserService::ProfileIsManaged(profile_))
+    return;
+#endif
+
   switch (type) {
     case chrome::NOTIFICATION_GOOGLE_SIGNED_OUT:
       ShutdownUserCloudPolicyManager();
       break;
     case chrome::NOTIFICATION_IMPORT_FINISHED:
     case chrome::NOTIFICATION_PROFILE_ADDED: {
       // A new profile has been loaded - if it's signed in, then initialize the
       // UCPM, otherwise shut down the UCPM (which deletes any cached policy
       // data). This must be done here instead of at constructor time because
       // the Profile is not fully initialized when this object is constructed
       // (DoFinalInit() has not yet been called, so ProfileIOData and
       // SSLConfigServiceManager have not been created yet).
       // TODO(atwilson): Switch to using a timer instead, to avoid contention
       // with other services at startup (http://crbug.com/165468).
       SigninManager* signin_manager =
           SigninManagerFactory::GetForProfile(profile_);
       std::string username = signin_manager->GetAuthenticatedUsername();
       if (username.empty())
         ShutdownUserCloudPolicyManager();
       else
         InitializeForSignedInUser();
       break;
     }
     case chrome::NOTIFICATION_TOKEN_AVAILABLE: {
       const TokenService::TokenAvailableDetails& token_details =
           *(content::Details<const TokenService::TokenAvailableDetails>(
               details).ptr());
       if (token_details.service() ==
-          GaiaConstants::kGaiaOAuth2LoginRefreshToken) {
+              GaiaConstants::kGaiaOAuth2LoginRefreshToken) {
         SigninManager* signin_manager =
             SigninManagerFactory::GetForProfile(profile_);
         std::string username = signin_manager->GetAuthenticatedUsername();
         // Should not have GAIA tokens if the user isn't signed in.
         DCHECK(!username.empty());
         // TokenService now has a refresh token (implying that the user is
         // signed in) so initialize the UserCloudPolicyManager.
         InitializeForSignedInUser();
       }
       break;
@@ skipping 169 matching lines @@
   // before UserCloudPolicyManager shuts down the CloudPolicyClient.
   registration_helper_.reset();
   StopObserving();
 }
 
 UserCloudPolicyManager* UserPolicySigninService::GetManager() {
   return UserCloudPolicyManagerFactory::GetForProfile(profile_);
 }
 
 }  // namespace policy