#ifndef CHROME_BROWSER_CHROMEOS_OWNERSHIP_OWNER_SETTINGS_SERVICE_CHROMEOS_H_
#define CHROME_BROWSER_CHROMEOS_OWNERSHIP_OWNER_SETTINGS_SERVICE_CHROMEOS_H_
-#include <deque>
+#include <string>
#include <vector>
#include "base/callback_forward.h"
-#include "base/compiler_specific.h"
+#include "base/containers/scoped_ptr_hash_map.h"
#include "base/macros.h"
+#include "base/values.h"
+#include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
#include "chrome/browser/chromeos/settings/device_settings_service.h"
#include "chromeos/dbus/session_manager_client.h"
#include "components/keyed_service/core/keyed_service.h"
namespace chromeos {
-class SessionManagerOperation;
-
// The class is a profile-keyed service which holds public/private
// keypair corresponds to a profile. The keypair is reloaded automatically when
// profile is created and TPM token is ready. Note that the private part of a
// (crbug.com/230018).
class OwnerSettingsServiceChromeOS : public ownership::OwnerSettingsService,
public content::NotificationObserver,
- public SessionManagerClient::Observer {
+ public SessionManagerClient::Observer,
+ public DeviceSettingsService::Observer {
public:
virtual ~OwnerSettingsServiceChromeOS();
void OnTPMTokenReady(bool tpm_token_enabled);
// ownership::OwnerSettingsService implementation:
- virtual void SignAndStorePolicyAsync(
- scoped_ptr<enterprise_management::PolicyData> policy,
- const base::Closure& callback) OVERRIDE;
+ virtual bool HandlesSetting(const std::string& setting) override;
+ virtual bool Set(const std::string& setting,
+ const base::Value& value) override;
+ virtual bool CommitTentativeDeviceSettings(
+ scoped_ptr<enterprise_management::PolicyData> policy) override;
// NotificationObserver implementation:
virtual void Observe(int type,
const content::NotificationSource& source,
- const content::NotificationDetails& details) OVERRIDE;
+ const content::NotificationDetails& details) override;
// SessionManagerClient::Observer:
- virtual void OwnerKeySet(bool success) OVERRIDE;
+ virtual void OwnerKeySet(bool success) override;
+
+ // DeviceSettingsService::Observer:
+ virtual void OwnershipStatusChanged() override;
+ virtual void DeviceSettingsUpdated() override;
+ virtual void OnDeviceSettingsServiceShutdown() override;
// Checks if the user is the device owner, without the user profile having to
// been initialized. Should be used only if login state is in safe mode.
const scoped_refptr<ownership::OwnerKeyUtil>& owner_key_util,
const IsOwnerCallback& callback);
- static void SetDeviceSettingsServiceForTesting(
- DeviceSettingsService* device_settings_service);
+ // Assembles PolicyData based on |settings|, |policy_data| and
+ // |user_id|.
+ static scoped_ptr<enterprise_management::PolicyData> AssemblePolicy(
+ const std::string& user_id,
+ const enterprise_management::PolicyData* policy_data,
+ const enterprise_management::ChromeDeviceSettingsProto* settings);
+
+ // Updates device |settings|.
+ static void UpdateDeviceSettings(
+ const std::string& path,
+ const base::Value& value,
+ enterprise_management::ChromeDeviceSettingsProto& settings);
+
+ bool has_pending_changes() const {
+ return !pending_changes_.empty() || tentative_settings_.get();
+ }
private:
friend class OwnerSettingsServiceChromeOSFactory;
OwnerSettingsServiceChromeOS(
+ DeviceSettingsService* device_settings_service,
Profile* profile,
const scoped_refptr<ownership::OwnerKeyUtil>& owner_key_util);
virtual void ReloadKeypairImpl(const base::Callback<
void(const scoped_refptr<ownership::PublicKey>& public_key,
const scoped_refptr<ownership::PrivateKey>& private_key)>& callback)
- OVERRIDE;
+ override;
// Possibly notifies DeviceSettingsService that owner's keypair is loaded.
- virtual void OnPostKeypairLoadedActions() OVERRIDE;
+ virtual void OnPostKeypairLoadedActions() override;
- // Performs next operation in the queue.
- void StartNextOperation();
+ // Tries to apply recent changes to device settings proto, sign it and store.
+ void StorePendingChanges();
- // Called when sign-and-store operation completes it's work.
- void HandleCompletedOperation(const base::Closure& callback,
- SessionManagerOperation* operation,
- DeviceSettingsService::Status status);
+ // Called when current device settings are successfully signed.
+ // Sends signed settings for storage.
+ void OnPolicyAssembledAndSigned(
+ scoped_ptr<enterprise_management::PolicyFetchResponse> policy_response);
+
+ // Called by DeviceSettingsService when modified and signed device
+ // settings are stored. Notifies observers and tries to store device
+ // settings again.
+ void OnSignedPolicyStored(bool success);
+
+ DeviceSettingsService* device_settings_service_;
// Profile this service instance belongs to.
Profile* profile_;
// Whether TPM token still needs to be initialized.
bool waiting_for_tpm_token_;
- // The queue of pending sign-and-store operations. The first operation on the
- // queue is currently active; it gets removed and destroyed once it completes.
- std::deque<SessionManagerOperation*> pending_operations_;
+ // A set of pending changes to device settings.
+ base::ScopedPtrHashMap<std::string, base::Value> pending_changes_;
+
+ // A protobuf containing pending changes to device settings.
+ scoped_ptr<enterprise_management::ChromeDeviceSettingsProto>
+ tentative_settings_;
content::NotificationRegistrar registrar_;
base::WeakPtrFactory<OwnerSettingsServiceChromeOS> weak_factory_;
+ base::WeakPtrFactory<OwnerSettingsServiceChromeOS> store_settings_factory_;
+
DISALLOW_COPY_AND_ASSIGN(OwnerSettingsServiceChromeOS);
};
projects / platform / framework / web / crosswalk.git / blobdiff