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 policy still
  45     // not signed and stored.
  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   virtual ~OwnerSettingsService();
  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   // Sets a bunch of device settings accumulated before ownership gets
  95   // established.
  96   //
  97   // TODO (ygorshenin@, crbug.com/230018): that this is a temporary
  98   // solution and should be removed.
  99   virtual bool CommitTentativeDeviceSettings(
 100       scoped_ptr<enterprise_management::PolicyData> policy) = 0;
 101
 102   bool SetBoolean(const std::string& setting, bool value);
 103   bool SetInteger(const std::string& setting, int value);
 104   bool SetDouble(const std::string& setting, double value);
 105   bool SetString(const std::string& setting, const std::string& value);
 106
 107  protected:
 108   void ReloadKeypair();
 109
 110   void OnKeypairLoaded(const scoped_refptr<PublicKey>& public_key,
 111                        const scoped_refptr<PrivateKey>& private_key);
 112
 113   // Platform-specific keypair loading algorithm.
 114   virtual void ReloadKeypairImpl(const base::Callback<
 115       void(const scoped_refptr<PublicKey>& public_key,
 116            const scoped_refptr<PrivateKey>& private_key)>& callback) = 0;
 117
 118   // Plafrom-specific actions which should be performed when keypair is loaded.
 119   virtual void OnPostKeypairLoadedActions() = 0;
 120
 121   scoped_refptr<ownership::PublicKey> public_key_;
 122
 123   scoped_refptr<ownership::PrivateKey> private_key_;
 124
 125   scoped_refptr<ownership::OwnerKeyUtil> owner_key_util_;
 126
 127   std::vector<IsOwnerCallback> pending_is_owner_callbacks_;
 128
 129   ObserverList<Observer> observers_;
 130
 131   base::ThreadChecker thread_checker_;
 132
 133  private:
 134   base::WeakPtrFactory<OwnerSettingsService> weak_factory_;
 135
 136   DISALLOW_COPY_AND_ASSIGN(OwnerSettingsService);
 137 };
 138
 139 }  // namespace ownership
 140
 141 #endif  // COMPONENTS_OWNERSHIP_OWNER_SETTINGS_SERVICE_H_