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 <string>
   9 #include <vector>
  10
  11 #include "base/callback_forward.h"
  12 #include "base/macros.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.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 "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       scoped_ptr<enterprise_management::PolicyFetchResponse> policy_response)>
  56       AssembleAndSignPolicyAsyncCallback;
  57
  58   typedef base::Callback<void(bool is_owner)> IsOwnerCallback;
  59
  60   explicit OwnerSettingsService(
  61       const scoped_refptr<ownership::OwnerKeyUtil>& owner_key_util);
  62   ~OwnerSettingsService() override;
  63
  64   base::WeakPtr<OwnerSettingsService> as_weak_ptr() {
  65     return weak_factory_.GetWeakPtr();
  66   }
  67
  68   void AddObserver(Observer* observer);
  69
  70   void RemoveObserver(Observer* observer);
  71
  72   // Returns whether current user is owner or not. When this method
  73   // is called too early, incorrect result can be returned because
  74   // private key loading may be in progress.
  75   bool IsOwner();
  76
  77   // Determines whether current user is owner or not, responds via
  78   // |callback|.
  79   void IsOwnerAsync(const IsOwnerCallback& callback);
  80
  81   // Assembles and signs |policy| on the |task_runner|, responds on
  82   // the original thread via |callback|.
  83   bool AssembleAndSignPolicyAsync(
  84       base::TaskRunner* task_runner,
  85       scoped_ptr<enterprise_management::PolicyData> policy,
  86       const AssembleAndSignPolicyAsyncCallback& callback);
  87
  88   // Checks whether |setting| is handled by OwnerSettingsService.
  89   virtual bool HandlesSetting(const std::string& setting) = 0;
  90
  91   // Sets |setting| value to |value|.
  92   virtual bool Set(const std::string& setting, const base::Value& value) = 0;
  93
  94   // Convenience functions for manipulating lists. Note that the following
  95   // functions employs a read, modify and write pattern. If there're
  96   // pending updates to |setting|, value cache they read from might not
  97   // be fresh and multiple calls to those function would lose data.
  98   virtual bool AppendToList(const std::string& setting,
  99                             const base::Value& value) = 0;
 100   virtual bool RemoveFromList(const std::string& setting,
 101                               const base::Value& value) = 0;
 102
 103   // Sets a bunch of device settings accumulated before ownership gets
 104   // established.
 105   //
 106   // TODO (ygorshenin@, crbug.com/230018): that this is a temporary
 107   // solution and should be removed.
 108   virtual bool CommitTentativeDeviceSettings(
 109       scoped_ptr<enterprise_management::PolicyData> policy) = 0;
 110
 111   bool SetBoolean(const std::string& setting, bool value);
 112   bool SetInteger(const std::string& setting, int value);
 113   bool SetDouble(const std::string& setting, double value);
 114   bool SetString(const std::string& setting, const std::string& value);
 115
 116  protected:
 117   void ReloadKeypair();
 118
 119   void OnKeypairLoaded(const scoped_refptr<PublicKey>& public_key,
 120                        const scoped_refptr<PrivateKey>& private_key);
 121
 122   // Platform-specific keypair loading algorithm.
 123   virtual void ReloadKeypairImpl(const base::Callback<
 124       void(const scoped_refptr<PublicKey>& public_key,
 125            const scoped_refptr<PrivateKey>& private_key)>& callback) = 0;
 126
 127   // Plafrom-specific actions which should be performed when keypair is loaded.
 128   virtual void OnPostKeypairLoadedActions() = 0;
 129
 130   scoped_refptr<ownership::PublicKey> public_key_;
 131
 132   scoped_refptr<ownership::PrivateKey> private_key_;
 133
 134   scoped_refptr<ownership::OwnerKeyUtil> owner_key_util_;
 135
 136   std::vector<IsOwnerCallback> pending_is_owner_callbacks_;
 137
 138   base::ObserverList<Observer> observers_;
 139
 140   base::ThreadChecker thread_checker_;
 141
 142  private:
 143   base::WeakPtrFactory<OwnerSettingsService> weak_factory_;
 144
 145   DISALLOW_COPY_AND_ASSIGN(OwnerSettingsService);
 146 };
 147
 148 }  // namespace ownership
 149
 150 #endif  // COMPONENTS_OWNERSHIP_OWNER_SETTINGS_SERVICE_H_