src/chrome/browser/policy/cloud/user_policy_signin_service_base.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_POLICY_CLOUD_USER_POLICY_SIGNIN_SERVICE_BASE_H_
   6 #define CHROME_BROWSER_POLICY_CLOUD_USER_POLICY_SIGNIN_SERVICE_BASE_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "components/keyed_service/core/keyed_service.h"
  17 #include "components/policy/core/common/cloud/cloud_policy_client.h"
  18 #include "components/policy/core/common/cloud/cloud_policy_service.h"
  19 #include "components/signin/core/browser/signin_manager.h"
  20 #include "content/public/browser/notification_observer.h"
  21 #include "content/public/browser/notification_registrar.h"
  22
  23 class PrefService;
  24 class Profile;
  25
  26 namespace net {
  27 class URLRequestContextGetter;
  28 }
  29
  30 namespace policy {
  31
  32 class DeviceManagementService;
  33 class UserCloudPolicyManager;
  34
  35 // The UserPolicySigninService is responsible for interacting with the policy
  36 // infrastructure (mainly UserCloudPolicyManager) to load policy for the signed
  37 // in user. This is the base class that contains shared behavior.
  38 //
  39 // At signin time, this class initializes the UCPM and loads policy before any
  40 // other signed in services are initialized. After each restart, this class
  41 // ensures that the CloudPolicyClient is registered (in case the policy server
  42 // was offline during the initial policy fetch) and if not it initiates a fresh
  43 // registration process.
  44 //
  45 // Finally, if the user signs out, this class is responsible for shutting down
  46 // the policy infrastructure to ensure that any cached policy is cleared.
  47 class UserPolicySigninServiceBase : public KeyedService,
  48                                     public CloudPolicyClient::Observer,
  49                                     public CloudPolicyService::Observer,
  50                                     public content::NotificationObserver,
  51                                     public SigninManagerBase::Observer {
  52  public:
  53   // The callback invoked once policy registration is complete. Passed
  54   // |dm_token| and |client_id| parameters are empty if policy registration
  55   // failed.
  56   typedef base::Callback<void(const std::string& dm_token,
  57                               const std::string& client_id)>
  58       PolicyRegistrationCallback;
  59
  60   // The callback invoked once policy fetch is complete. Passed boolean
  61   // parameter is set to true if the policy fetch succeeded.
  62   typedef base::Callback<void(bool)> PolicyFetchCallback;
  63
  64   // Creates a UserPolicySigninServiceBase associated with the passed |profile|.
  65   UserPolicySigninServiceBase(
  66       Profile* profile,
  67       PrefService* local_state,
  68       DeviceManagementService* device_management_service,
  69       UserCloudPolicyManager* policy_manager,
  70       SigninManager* signin_manager,
  71       scoped_refptr<net::URLRequestContextGetter> system_request_context);
  72   virtual ~UserPolicySigninServiceBase();
  73
  74   // Initiates a policy fetch as part of user signin, using a |dm_token| and
  75   // |client_id| fetched via RegisterForPolicy(). |callback| is invoked
  76   // once the policy fetch is complete, passing true if the policy fetch
  77   // succeeded.
  78   void FetchPolicyForSignedInUser(
  79       const std::string& username,
  80       const std::string& dm_token,
  81       const std::string& client_id,
  82       scoped_refptr<net::URLRequestContextGetter> profile_request_context,
  83       const PolicyFetchCallback& callback);
  84
  85   // SigninManagerBase::Observer implementation:
  86   virtual void GoogleSignedOut(const std::string& account_id,
  87                                const std::string& username) OVERRIDE;
  88
  89   // content::NotificationObserver implementation:
  90   virtual void Observe(int type,
  91                        const content::NotificationSource& source,
  92                        const content::NotificationDetails& details) OVERRIDE;
  93
  94   // CloudPolicyService::Observer implementation:
  95   virtual void OnInitializationCompleted(CloudPolicyService* service) OVERRIDE;
  96
  97   // CloudPolicyClient::Observer implementation:
  98   virtual void OnPolicyFetched(CloudPolicyClient* client) OVERRIDE;
  99   virtual void OnRegistrationStateChanged(CloudPolicyClient* client) OVERRIDE;
 100   virtual void OnClientError(CloudPolicyClient* client) OVERRIDE;
 101
 102   // KeyedService implementation:
 103   virtual void Shutdown() OVERRIDE;
 104
 105   void SetSystemRequestContext(
 106       scoped_refptr<net::URLRequestContextGetter> request_context);
 107
 108  protected:
 109   net::URLRequestContextGetter* system_request_context() {
 110     return system_request_context_.get();
 111   }
 112
 113   // Returns a CloudPolicyClient to perform a registration with the DM server,
 114   // or NULL if |username| shouldn't register for policy management.
 115   scoped_ptr<CloudPolicyClient> CreateClientForRegistrationOnly(
 116       const std::string& username);
 117
 118   // Returns false if cloud policy is disabled or if the passed |email_address|
 119   // is definitely not from a hosted domain (according to the blacklist in
 120   // BrowserPolicyConnector::IsNonEnterpriseUser()).
 121   bool ShouldLoadPolicyForUser(const std::string& email_address);
 122
 123   // Invoked to initialize the UserPolicySigninService once its owning Profile
 124   // becomes ready. If the Profile has a signed-in account associated with it
 125   // at startup then this initializes the cloud policy manager by calling
 126   // InitializeForSignedInUser(); otherwise it clears any stored policies.
 127   void InitializeOnProfileReady(Profile* profile);
 128
 129   // Invoked to initialize the cloud policy service for |username|, which is the
 130   // account associated with the Profile that owns this service. This is invoked
 131   // from InitializeOnProfileReady() if the Profile already has a signed-in
 132   // account at startup, or (on the desktop platforms) as soon as the user
 133   // signs-in and an OAuth2 login refresh token becomes available.
 134   void InitializeForSignedInUser(
 135       const std::string& username,
 136       scoped_refptr<net::URLRequestContextGetter> profile_request_context);
 137
 138   // Initializes the cloud policy manager with the passed |client|. This is
 139   // called from InitializeForSignedInUser() when the Profile already has a
 140   // signed in account at startup, and from FetchPolicyForSignedInUser() during
 141   // the initial policy fetch after signing in.
 142   virtual void InitializeUserCloudPolicyManager(
 143       const std::string& username,
 144       scoped_ptr<CloudPolicyClient> client);
 145
 146   // Prepares for the UserCloudPolicyManager to be shutdown due to
 147   // user signout or profile destruction.
 148   virtual void PrepareForUserCloudPolicyManagerShutdown();
 149
 150   // Shuts down the UserCloudPolicyManager (for example, after the user signs
 151   // out) and deletes any cached policy.
 152   virtual void ShutdownUserCloudPolicyManager();
 153
 154   // Convenience helpers to get the associated UserCloudPolicyManager and
 155   // SigninManager.
 156   UserCloudPolicyManager* policy_manager() { return policy_manager_; }
 157   SigninManager* signin_manager() { return signin_manager_; }
 158
 159   content::NotificationRegistrar* registrar() { return &registrar_; }
 160
 161  private:
 162   // Helper functions to create a request context for use by CloudPolicyClients.
 163   scoped_refptr<net::URLRequestContextGetter> CreateUserRequestContext(
 164       scoped_refptr<net::URLRequestContextGetter> profile_request_context);
 165   scoped_refptr<net::URLRequestContextGetter> CreateSystemRequestContext();
 166
 167   // Weak pointer to the UserCloudPolicyManager and SigninManager this service
 168   // is associated with.
 169   UserCloudPolicyManager* policy_manager_;
 170   SigninManager* signin_manager_;
 171
 172   content::NotificationRegistrar registrar_;
 173
 174   PrefService* local_state_;
 175   DeviceManagementService* device_management_service_;
 176   scoped_refptr<net::URLRequestContextGetter> system_request_context_;
 177
 178   base::WeakPtrFactory<UserPolicySigninServiceBase> weak_factory_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(UserPolicySigninServiceBase);
 181 };
 182
 183 }  // namespace policy
 184
 185 #endif  // CHROME_BROWSER_POLICY_CLOUD_USER_POLICY_SIGNIN_SERVICE_BASE_H_