components/ownership/owner_settings_service.h

   1 // Copyright 2014 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 COMPONENTS_OWNERSHIP_OWNER_SETTINGS_SERVICE_H_
   6 #define COMPONENTS_OWNERSHIP_OWNER_SETTINGS_SERVICE_H_
   7
   8 #include <memory>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/callback_forward.h"
  13 #include "base/macros.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/observer_list.h"
  17 #include "base/threading/thread_checker.h"
  18 #include "components/keyed_service/core/keyed_service.h"
  19 #include "components/ownership/ownership_export.h"
  20 #include "components/policy/proto/device_management_backend.pb.h"
  21
  22 namespace base {
  23 class TaskRunner;
  24 class Value;
  25 }
  26
  27 namespace ownership {
  28 class OwnerKeyUtil;
  29 class PrivateKey;
  30 class PublicKey;
  31
  32 // This class is a common interface for platform-specific classes
  33 // which deal with ownership, keypairs and owner-related settings.
  34 class OWNERSHIP_EXPORT OwnerSettingsService : public KeyedService {
  35  public:
  36   class Observer {
  37    public:
  38     virtual ~Observer() {}
  39
  40     // Called when signed policy was stored, or when an error happed during
  41     // policy storage..
  42     virtual void OnSignedPolicyStored(bool success) {}
  43
  44     // Called when tentative changes were made to policy, but the
  45     // policy is not signed and stored yet.
  46     //
  47     // TODO (ygorshenin@, crbug.com/230018): get rid of the method
  48     // since it creates DeviceSettingsService's dependency on
  49     // OwnerSettingsService.
  50     virtual void OnTentativeChangesInPolicy(
  51         const enterprise_management::PolicyData& policy_data) {}
  52   };
  53
  54   typedef base::Callback<void(
  55       std::unique_ptr<enterprise_management::PolicyFetchResponse>
  56           policy_response)>
  57       AssembleAndSignPolicyAsyncCallback;
  58
  59   typedef base::Callback<void(bool is_owner)> IsOwnerCallback;
  60
  61   explicit OwnerSettingsService(
  62       const scoped_refptr<ownership::OwnerKeyUtil>& owner_key_util);
  63   ~OwnerSettingsService() override;
  64
  65   base::WeakPtr<OwnerSettingsService> as_weak_ptr() {
  66     return weak_factory_.GetWeakPtr();
  67   }
  68
  69   void AddObserver(Observer* observer);
  70
  71   void RemoveObserver(Observer* observer);
  72
  73   // Returns whether current user is owner or not. When this method
  74   // is called too early, incorrect result can be returned because
  75   // private key loading may be in progress.
  76   virtual bool IsOwner();
  77
  78   // Determines whether current user is owner or not, responds via
  79   // |callback|.
  80   virtual void IsOwnerAsync(const IsOwnerCallback& callback);
  81
  82   // Assembles and signs |policy| on the |task_runner|, responds on
  83   // the original thread via |callback|.
  84   bool AssembleAndSignPolicyAsync(
  85       base::TaskRunner* task_runner,
  86       std::unique_ptr<enterprise_management::PolicyData> policy,
  87       const AssembleAndSignPolicyAsyncCallback& callback);
  88
  89   // Checks whether |setting| is handled by OwnerSettingsService.
  90   virtual bool HandlesSetting(const std::string& setting) = 0;
  91
  92   // Sets |setting| value to |value|.
  93   virtual bool Set(const std::string& setting, const base::Value& value) = 0;
  94
  95   // Convenience functions for manipulating lists. Note that the following
  96   // functions employs a read, modify and write pattern. If there're
  97   // pending updates to |setting|, value cache they read from might not
  98   // be fresh and multiple calls to those function would lose data.
  99   virtual bool AppendToList(const std::string& setting,
 100                             const base::Value& value) = 0;
 101   virtual bool RemoveFromList(const std::string& setting,
 102                               const base::Value& value) = 0;
 103
 104   // Sets a bunch of device settings accumulated before ownership gets
 105   // established.
 106   //
 107   // TODO (ygorshenin@, crbug.com/230018): that this is a temporary
 108   // solution and should be removed.
 109   virtual bool CommitTentativeDeviceSettings(
 110       std::unique_ptr<enterprise_management::PolicyData> policy) = 0;
 111
 112   bool SetBoolean(const std::string& setting, bool value);
 113   bool SetInteger(const std::string& setting, int value);
 114   bool SetDouble(const std::string& setting, double value);
 115   bool SetString(const std::string& setting, const std::string& value);
 116
 117  protected:
 118   void ReloadKeypair();
 119
 120   void OnKeypairLoaded(const scoped_refptr<PublicKey>& public_key,
 121                        const scoped_refptr<PrivateKey>& private_key);
 122
 123   // Platform-specific keypair loading algorithm.
 124   virtual void ReloadKeypairImpl(const base::Callback<
 125       void(const scoped_refptr<PublicKey>& public_key,
 126            const scoped_refptr<PrivateKey>& private_key)>& callback) = 0;
 127
 128   // Plafrom-specific actions which should be performed when keypair is loaded.
 129   virtual void OnPostKeypairLoadedActions() = 0;
 130
 131   scoped_refptr<ownership::PublicKey> public_key_;
 132
 133   scoped_refptr<ownership::PrivateKey> private_key_;
 134
 135   scoped_refptr<ownership::OwnerKeyUtil> owner_key_util_;
 136
 137   std::vector<IsOwnerCallback> pending_is_owner_callbacks_;
 138
 139   base::ObserverList<Observer> observers_;
 140
 141   base::ThreadChecker thread_checker_;
 142
 143  private:
 144   base::WeakPtrFactory<OwnerSettingsService> weak_factory_;
 145
 146   DISALLOW_COPY_AND_ASSIGN(OwnerSettingsService);
 147 };
 148
 149 }  // namespace ownership
 150
 151 #endif  // COMPONENTS_OWNERSHIP_OWNER_SETTINGS_SERVICE_H_