Home | History | Annotate | Download | only in settings 
      1 // Copyright (c) 2012 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_CHROMEOS_SETTINGS_SESSION_MANAGER_OPERATION_H_
      6 #define CHROME_BROWSER_CHROMEOS_SETTINGS_SESSION_MANAGER_OPERATION_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/callback.h"
     10 #include "base/memory/ref_counted.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "chrome/browser/chromeos/policy/device_cloud_policy_validator.h"
     13 #include "chrome/browser/chromeos/settings/device_settings_service.h"
     14 
     15 namespace enterprise_management {
     16 class ChromeDeviceSettingsProto;
     17 class PolicyData;
     18 class PolicyFetchResponse;
     19 }
     20 
     21 namespace chromeos {
     22 
     23 class OwnerKeyUtil;
     24 class SessionManagerClient;
     25 
     26 // Handles a single transaction with session manager. This is a virtual base
     27 // class that contains common infrastructure for key and policy loading. There
     28 // are subclasses for loading, storing and signing policy blobs.
     29 class SessionManagerOperation {
     30  public:
     31   typedef base::Callback<void(SessionManagerOperation*,
     32                               DeviceSettingsService::Status)> Callback;
     33 
     34   // Creates a new load operation.
     35   explicit SessionManagerOperation(const Callback& callback);
     36   virtual ~SessionManagerOperation();
     37 
     38   // Starts the operation.
     39   void Start(SessionManagerClient* session_manager_client,
     40              scoped_refptr<OwnerKeyUtil> owner_key_util,
     41              scoped_refptr<OwnerKey> owner_key);
     42 
     43   // Restarts a load operation (if that part is already in progress).
     44   void RestartLoad(bool key_changed);
     45 
     46   // Accessors for recovering the loaded policy data after completion.
     47   scoped_ptr<enterprise_management::PolicyData>& policy_data() {
     48     return policy_data_;
     49   }
     50   scoped_ptr<enterprise_management::ChromeDeviceSettingsProto>&
     51       device_settings() {
     52     return device_settings_;
     53   }
     54 
     55   // Owner key as configured/loaded from disk.
     56   scoped_refptr<OwnerKey> owner_key() {
     57     return owner_key_;
     58   }
     59 
     60   // Whether the load operation is underway.
     61   bool is_loading() const {
     62     return is_loading_;
     63   }
     64 
     65   void set_force_key_load(bool force_key_load) {
     66     force_key_load_ = force_key_load;
     67   }
     68 
     69  protected:
     70   // Runs the operation. The result is reported through |callback_|.
     71   virtual void Run() = 0;
     72 
     73   // Ensures the owner key is loaded.
     74   void EnsureOwnerKey(const base::Closure& callback);
     75 
     76   // Starts a load operation.
     77   void StartLoading();
     78 
     79   // Reports the result status of the operation. Once this gets called, the
     80   // operation should not perform further processing or trigger callbacks.
     81   void ReportResult(DeviceSettingsService::Status status);
     82 
     83   SessionManagerClient* session_manager_client() {
     84     return session_manager_client_;
     85   }
     86 
     87  private:
     88   // Loads the owner key from disk. Must be run on a thread that can do I/O.
     89   static scoped_refptr<OwnerKey> LoadOwnerKey(
     90       scoped_refptr<OwnerKeyUtil> util,
     91       scoped_refptr<OwnerKey> current_key);
     92 
     93   // Stores the owner key loaded by LoadOwnerKey and calls |callback|.
     94   void StoreOwnerKey(const base::Closure& callback,
     95                      scoped_refptr<OwnerKey> new_key);
     96 
     97   // Triggers a device settings load.
     98   void RetrieveDeviceSettings();
     99 
    100   // Validates device settings after retrieval from session_manager.
    101   void ValidateDeviceSettings(const std::string& policy_blob);
    102 
    103   // Extracts status and device settings from the validator and reports them.
    104   void ReportValidatorStatus(policy::DeviceCloudPolicyValidator* validator);
    105 
    106   SessionManagerClient* session_manager_client_;
    107   scoped_refptr<OwnerKeyUtil> owner_key_util_;
    108 
    109   base::WeakPtrFactory<SessionManagerOperation> weak_factory_;
    110 
    111   Callback callback_;
    112 
    113   scoped_refptr<OwnerKey> owner_key_;
    114   bool force_key_load_;
    115 
    116   bool is_loading_;
    117   scoped_ptr<enterprise_management::PolicyData> policy_data_;
    118   scoped_ptr<enterprise_management::ChromeDeviceSettingsProto> device_settings_;
    119 
    120   DISALLOW_COPY_AND_ASSIGN(SessionManagerOperation);
    121 };
    122 
    123 // This operation loads the public owner key from disk if appropriate, fetches
    124 // the policy blob from session manager, and validates the loaded policy blob.
    125 class LoadSettingsOperation : public SessionManagerOperation {
    126  public:
    127   // Creates a new load operation.
    128   explicit LoadSettingsOperation(const Callback& callback);
    129   virtual ~LoadSettingsOperation();
    130 
    131  protected:
    132   // SessionManagerOperation:
    133   virtual void Run() OVERRIDE;
    134 
    135  private:
    136   DISALLOW_COPY_AND_ASSIGN(LoadSettingsOperation);
    137 };
    138 
    139 // Stores a pre-generated policy blob and reloads the device settings from
    140 // session_manager.
    141 class StoreSettingsOperation : public SessionManagerOperation {
    142  public:
    143   // Creates a new store operation.
    144   StoreSettingsOperation(
    145       const Callback& callback,
    146       scoped_ptr<enterprise_management::PolicyFetchResponse> policy);
    147   virtual ~StoreSettingsOperation();
    148 
    149  protected:
    150   // SessionManagerOperation:
    151   virtual void Run() OVERRIDE;
    152 
    153  private:
    154   // Handles the result of the store operation and triggers the load.
    155   void HandleStoreResult(bool success);
    156 
    157   scoped_ptr<enterprise_management::PolicyFetchResponse> policy_;
    158 
    159   base::WeakPtrFactory<StoreSettingsOperation> weak_factory_;
    160 
    161   DISALLOW_COPY_AND_ASSIGN(StoreSettingsOperation);
    162 };
    163 
    164 // Signs device settings and stores the resulting blob to session_manager.
    165 class SignAndStoreSettingsOperation : public SessionManagerOperation {
    166  public:
    167   // Creates a new sign-and-store operation.
    168   SignAndStoreSettingsOperation(
    169       const Callback& callback,
    170       scoped_ptr<enterprise_management::ChromeDeviceSettingsProto> new_settings,
    171       const std::string& username);
    172   virtual ~SignAndStoreSettingsOperation();
    173 
    174   // SessionManagerOperation:
    175   virtual void Run() OVERRIDE;
    176 
    177  private:
    178   // Given an owner key, starts the signing operation.
    179   void StartSigning();
    180 
    181   // Builds the policy blob and signs it using the owner key.
    182   static std::string AssembleAndSignPolicy(
    183       scoped_ptr<enterprise_management::ChromeDeviceSettingsProto> settings,
    184       const std::string& username,
    185       scoped_refptr<OwnerKey> owner_key);
    186 
    187   // Stores the signed device settings blob.
    188   void StoreDeviceSettingsBlob(std::string device_settings_blob);
    189 
    190   // Handles the result of the store operation and triggers the load.
    191   void HandleStoreResult(bool success);
    192 
    193   scoped_ptr<enterprise_management::ChromeDeviceSettingsProto> new_settings_;
    194   std::string username_;
    195 
    196   base::WeakPtrFactory<SignAndStoreSettingsOperation> weak_factory_;
    197 
    198   DISALLOW_COPY_AND_ASSIGN(SignAndStoreSettingsOperation);
    199 };
    200 
    201 }  // namespace
    202 
    203 #endif  // CHROME_BROWSER_CHROMEOS_SETTINGS_SESSION_MANAGER_OPERATION_H_
    204