Enable cloud policy by default.

chrome/browser/policy/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/user_policy_signin_service.h"
 
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud_policy_service.h"
@@ skipping 30 matching lines @@
 }  // namespace
 
 namespace policy {
 
 UserPolicySigninService::UserPolicySigninService(
     Profile* profile)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       profile_(profile),
       pending_fetch_(false) {
 
-  if (!profile_->GetPrefs()->GetBoolean(prefs::kLoadCloudPolicyOnSignin))
+  if (profile_->GetPrefs()->GetBoolean(prefs::kDisableCloudPolicyOnSignin))
     return;
 
   // 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,
                  content::Source<TokenService>(
                      TokenServiceFactory::GetForProfile(profile)));
 
   // TokenService should not yet have loaded its tokens since this happens in
   // the background after PKS initialization - so this service should always be
   // created before the oauth token is available.
   DCHECK(!TokenServiceFactory::GetForProfile(profile_)->HasOAuthLoginToken());
 
   // Register a listener to be called back once the current profile has finished
   // initializing, so we can startup the UserCloudPolicyManager.
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_ADDED,
                  content::Source<Profile>(profile));
 
   // Make sure we've initialized the DeviceManagementService. It's OK to
   // call this multiple times so we do it every time we create an instance of
   // this class (every time a new profile is loaded).
+  // TODO(atwilson): Move this to BrowserPolicyConnector::Init()
+  // (http://crbug.com/165468).
   g_browser_process->browser_policy_connector()->
       ScheduleServiceInitialization(
           kPolicyServiceInitializationDelayMilliseconds);
 }
 
 UserPolicySigninService::~UserPolicySigninService() {}
 
 void UserPolicySigninService::FetchPolicyForSignedInUser(
     const std::string& oauth2_access_token,
     const PolicyFetchCallback& callback) {
@@ skipping 40 matching lines @@
   DCHECK(manager->core()->service());
   DCHECK(manager->core()->client());
   manager->core()->service()->AddObserver(this);
   manager->core()->client()->AddObserver(this);
 }
 
 void UserPolicySigninService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
+  // 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;
+  }
+
   switch (type) {
     case chrome::NOTIFICATION_GOOGLE_SIGNED_OUT:
       ShutdownUserCloudPolicyManager();
       break;
     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
@@ skipping 19 matching lines @@
         InitializeUserCloudPolicyManager();
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 bool UserPolicySigninService::ShouldLoadPolicyForSignedInUser() {
-  if (!profile_->GetPrefs()->GetBoolean(prefs::kLoadCloudPolicyOnSignin))
+  if (profile_->GetPrefs()->GetBoolean(prefs::kDisableCloudPolicyOnSignin))
     return false; // Cloud policy is disabled.
 
   const std::string& username = SigninManagerFactory::GetForProfile(profile_)->
       GetAuthenticatedUsername();
 
   if (username.empty())
     return false; // Not signed in.
 
   return !BrowserPolicyConnector::IsNonEnterpriseUser(username);
 }
@@ skipping 169 matching lines @@
 
 void UserPolicySigninService::Shutdown() {
   StopObserving();
 }
 
 UserCloudPolicyManager* UserPolicySigninService::GetManager() {
   return UserCloudPolicyManagerFactory::GetForProfile(profile_);
 }
 
 }  // namespace policy