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_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_
    159