src/chrome/browser/chromeos/settings/device_settings_provider.h

   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_DEVICE_SETTINGS_PROVIDER_H_
   6 #define CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_PROVIDER_H_
   7
   8 #include <deque>
   9 #include <string>
  10 #include <utility>
  11 #include <vector>
  12
  13 #include "base/basictypes.h"
  14 #include "base/callback.h"
  15 #include "base/gtest_prod_util.h"
  16 #include "base/memory/weak_ptr.h"
  17 #include "base/prefs/pref_value_map.h"
  18 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
  19 #include "chrome/browser/chromeos/settings/device_settings_service.h"
  20 #include "chromeos/settings/cros_settings_provider.h"
  21 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
  22
  23 namespace base {
  24 class Value;
  25 }
  26
  27 namespace enterprise_management {
  28 class ChromeDeviceSettingsProto;
  29 }  // namespace enterprise_management
  30
  31 namespace chromeos {
  32
  33 // CrosSettingsProvider implementation that works with device settings.
  34 class DeviceSettingsProvider : public CrosSettingsProvider,
  35                                public DeviceSettingsService::Observer {
  36  public:
  37   // The callback type that is called to get the device mode.
  38   typedef base::Callback<policy::DeviceMode(void)> GetDeviceModeCallback;
  39
  40   DeviceSettingsProvider(const NotifyObserversCallback& notify_cb,
  41                          DeviceSettingsService* device_settings_service);
  42   virtual ~DeviceSettingsProvider();
  43
  44   // Returns true if |path| is handled by this provider.
  45   static bool IsDeviceSetting(const std::string& name);
  46
  47   // CrosSettingsProvider implementation.
  48   virtual const base::Value* Get(const std::string& path) const OVERRIDE;
  49   virtual TrustedStatus PrepareTrustedValues(
  50       const base::Closure& callback) OVERRIDE;
  51   virtual bool HandlesSetting(const std::string& path) const OVERRIDE;
  52
  53  private:
  54   // CrosSettingsProvider implementation:
  55   virtual void DoSet(const std::string& path,
  56                      const base::Value& value) OVERRIDE;
  57
  58   // DeviceSettingsService::Observer implementation:
  59   virtual void OwnershipStatusChanged() OVERRIDE;
  60   virtual void DeviceSettingsUpdated() OVERRIDE;
  61
  62   // Populates in-memory cache from the local_state cache that is used to store
  63   // device settings before the device is owned and to speed up policy
  64   // availability before the policy blob is fetched on boot.
  65   void RetrieveCachedData();
  66
  67   // Stores a value from the |pending_changes_| queue in the device settings.
  68   // If the device is not owned yet the data ends up only in the local_state
  69   // cache and is serialized once ownership is acquired.
  70   void SetInPolicy();
  71
  72   // Parses the policy data and fills in |values_cache_|.
  73   void UpdateValuesCache(
  74       const enterprise_management::PolicyData& policy_data,
  75       const enterprise_management::ChromeDeviceSettingsProto& settings,
  76       TrustedStatus trusted_status);
  77
  78   // Applies the metrics policy and if not set migrates the legacy file.
  79   void ApplyMetricsSetting(bool use_file, bool new_value);
  80
  81   // Applies the data roaming policy.
  82   void ApplyRoamingSetting(bool new_value);
  83   void ApplyRoamingSettingFromProto(
  84       const enterprise_management::ChromeDeviceSettingsProto& settings);
  85
  86   // Applies any changes of the policies that are not handled by the respective
  87   // subsystems.
  88   void ApplySideEffects(
  89       const enterprise_management::ChromeDeviceSettingsProto& settings);
  90
  91   // In case of missing policy blob we should verify if this is upgrade of
  92   // machine owned from pre version 12 OS and the user never touched the device
  93   // settings. In this case revert to defaults and let people in until the owner
  94   // comes and changes that.
  95   bool MitigateMissingPolicy();
  96
  97   // Checks if the current cache value can be trusted for being representative
  98   // for the disk cache.
  99   TrustedStatus RequestTrustedEntity();
 100
 101   // Invokes UpdateFromService() to synchronize with |device_settings_service_|,
 102   // then triggers the next store operation if applicable.
 103   void UpdateAndProceedStoring();
 104
 105   // Re-reads state from |device_settings_service_|, adjusts
 106   // |trusted_status_| and calls UpdateValuesCache() if applicable. Returns true
 107   // if new settings have been loaded.
 108   bool UpdateFromService();
 109
 110   // Sends |device_settings_| to |device_settings_service_| for signing and
 111   // storage in session_manager.
 112   void StoreDeviceSettings();
 113
 114   // Checks the current ownership status to see whether the device owner is
 115   // logged in and writes the data accumulated in |migration_values_| to proper
 116   // device settings.
 117   void AttemptMigration();
 118
 119   // Pending callbacks that need to be invoked after settings verification.
 120   std::vector<base::Closure> callbacks_;
 121
 122   DeviceSettingsService* device_settings_service_;
 123   mutable PrefValueMap migration_values_;
 124
 125   TrustedStatus trusted_status_;
 126   DeviceSettingsService::OwnershipStatus ownership_status_;
 127
 128   // The device settings as currently reported through the CrosSettingsProvider
 129   // interface. This may be different from the actual current device settings
 130   // (which can be obtained from |device_settings_service_|) in case the device
 131   // does not have an owner yet or there are pending changes that have not yet
 132   // been written to session_manager.
 133   enterprise_management::ChromeDeviceSettingsProto device_settings_;
 134
 135   // A cache of values, indexed by the settings keys served through the
 136   // CrosSettingsProvider interface. This is always kept in sync with the raw
 137   // data found in |device_settings_|.
 138   PrefValueMap values_cache_;
 139
 140   // This is a queue for set requests, because those need to be sequential.
 141   typedef std::pair<std::string, base::Value*> PendingQueueElement;
 142   std::deque<PendingQueueElement> pending_changes_;
 143
 144   // Weak pointer factory for creating store operation callbacks.
 145   base::WeakPtrFactory<DeviceSettingsProvider> store_callback_factory_;
 146
 147   friend class DeviceSettingsProviderTest;
 148   FRIEND_TEST_ALL_PREFIXES(DeviceSettingsProviderTest,
 149                            InitializationTestUnowned);
 150   FRIEND_TEST_ALL_PREFIXES(DeviceSettingsProviderTest,
 151                            PolicyFailedPermanentlyNotification);
 152   FRIEND_TEST_ALL_PREFIXES(DeviceSettingsProviderTest, PolicyLoadNotification);
 153   DISALLOW_COPY_AND_ASSIGN(DeviceSettingsProvider);
 154 };
 155
 156 }  // namespace chromeos
 157
 158 #endif  // CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_PROVIDER_H_