policy: Remove SigninManager from UserCloudPolicyStore.

chrome/browser/policy/cloud/user_policy_signin_service_base.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/policy/cloud/user_policy_signin_service_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 27 matching lines @@
   // 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));
 }
 
 UserPolicySigninServiceBase::~UserPolicySigninServiceBase() {}
 
 void UserPolicySigninServiceBase::FetchPolicyForSignedInUser(
+    const std::string& username,
     scoped_ptr<CloudPolicyClient> client,
     const PolicyFetchCallback& callback) {
   DCHECK(client);
   DCHECK(client->is_registered());
   // The user has just signed in, so the UserCloudPolicyManager should not yet
   // be initialized. This routine will initialize the UserCloudPolicyManager
   // with the passed client and will proactively ask the client to fetch
   // policy without waiting for the CloudPolicyService to finish initialization.
   UserCloudPolicyManager* manager = GetManager();
   DCHECK(manager);
   DCHECK(!manager->core()->client());
-  InitializeUserCloudPolicyManager(client.Pass());
+  InitializeUserCloudPolicyManager(username, client.Pass());
   DCHECK(manager->IsClientRegistered());
 
   // Now initiate a policy fetch.
   manager->core()->service()->RefreshPolicy(callback);
 }
 
 void UserPolicySigninServiceBase::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ skipping 82 matching lines @@
   DCHECK(!username.empty());
   // We should not be called with a client already initialized.
   DCHECK(!GetManager() || !GetManager()->core()->client());
 
   // If the user should not get policy, just bail out.
   if (!GetManager() || !ShouldLoadPolicyForUser(username)) {
     DVLOG(1) << "Signed in user is not in the whitelist";
     return scoped_ptr<CloudPolicyClient>();
   }
 
+  GetManager()->SetSigninUsername(username);
+
   // If the DeviceManagementService is not yet initialized, start it up now.
   device_management_service_->ScheduleInitialization(0);
 
   // Create a new CloudPolicyClient for fetching the DMToken.
   return UserCloudPolicyManager::CreateCloudPolicyClient(
       device_management_service_);
 }
 
 bool UserPolicySigninServiceBase::ShouldLoadPolicyForUser(
     const std::string& username) {
@@ skipping 22 matching lines @@
     return;
   }
 
   UserCloudPolicyManager* manager = GetManager();
   // Initialize the UCPM if it is not already initialized.
   if (!manager->core()->service()) {
     // If there is no cached DMToken then we can detect this when the
     // OnInitializationCompleted() callback is invoked and this will
     // initiate a policy fetch.
     InitializeUserCloudPolicyManager(
+        username,
         UserCloudPolicyManager::CreateCloudPolicyClient(
             device_management_service_).Pass());
+  } else {
+    manager->SetSigninUsername(username);
   }
 
   // If the CloudPolicyService is initialized, kick off registration.
   // Otherwise OnInitializationCompleted is invoked as soon as the service
   // finishes its initialization.
   if (manager->core()->service()->IsInitializationComplete())
     OnInitializationCompleted(manager->core()->service());
 }
 
 void UserPolicySigninServiceBase::InitializeUserCloudPolicyManager(
+    const std::string& username,
     scoped_ptr<CloudPolicyClient> client) {
   UserCloudPolicyManager* manager = GetManager();
+  manager->SetSigninUsername(username);
   DCHECK(!manager->core()->client());
   manager->Connect(local_state_, request_context_, client.Pass());
   DCHECK(manager->core()->service());
 
   // Observe the client to detect errors fetching policy.
   manager->core()->client()->AddObserver(this);
   // Observe the service to determine when it's initialized.
   manager->core()->service()->AddObserver(this);
 }
 
 void UserPolicySigninServiceBase::ShutdownUserCloudPolicyManager() {
   PrepareForUserCloudPolicyManagerShutdown();
   UserCloudPolicyManager* manager = GetManager();
   if (manager)
     manager->DisconnectAndRemovePolicy();
 }
 
 UserCloudPolicyManager* UserPolicySigninServiceBase::GetManager() {
   return UserCloudPolicyManagerFactory::GetForProfile(profile_);
 }
 
 SigninManager* UserPolicySigninServiceBase::GetSigninManager() {
   return SigninManagerFactory::GetForProfile(profile_);
 }
 
 }  // namespace policy