Added key-value storage for pending changes to OwnerSettingsServiceChromeOS. This CL is an alternat…

chrome/browser/chromeos/ownership/owner_settings_service_chromeos.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 139 matching lines @@
 
 OwnerSettingsServiceChromeOS::OwnerSettingsServiceChromeOS(
     DeviceSettingsService* device_settings_service,
     Profile* profile,
     const scoped_refptr<OwnerKeyUtil>& owner_key_util)
     : ownership::OwnerSettingsService(owner_key_util),
       device_settings_service_(device_settings_service),
       profile_(profile),
       waiting_for_profile_creation_(true),
       waiting_for_tpm_token_(true),
-      has_pending_changes_(false),
       weak_factory_(this),
       store_settings_factory_(this) {
   if (TPMTokenLoader::IsInitialized()) {
     TPMTokenLoader::TPMTokenStatus tpm_token_status =
         TPMTokenLoader::Get()->IsTPMTokenEnabled(
             base::Bind(&OwnerSettingsServiceChromeOS::OnTPMTokenReady,
                        weak_factory_.GetWeakPtr()));
     waiting_for_tpm_token_ =
         tpm_token_status == TPMTokenLoader::TPM_TOKEN_STATUS_UNDETERMINED;
   }
 
   if (DBusThreadManager::IsInitialized() &&
       DBusThreadManager::Get()->GetSessionManagerClient()) {
     DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(this);
   }
 
   if (device_settings_service_)
     device_settings_service_->AddObserver(this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_CREATED,
                  content::Source<Profile>(profile_));
-
-  UpdateFromService();
 }
 
 OwnerSettingsServiceChromeOS::~OwnerSettingsServiceChromeOS() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (device_settings_service_)
     device_settings_service_->RemoveObserver(this);
 
   if (DBusThreadManager::IsInitialized() &&
       DBusThreadManager::Get()->GetSessionManagerClient()) {
@@ skipping 13 matching lines @@
 
 bool OwnerSettingsServiceChromeOS::HandlesSetting(const std::string& setting) {
   return DeviceSettingsProvider::IsDeviceSetting(setting);
 }
 
 bool OwnerSettingsServiceChromeOS::Set(const std::string& setting,
                                        const base::Value& value) {
   if (!IsOwner() && !IsOwnerInTests(user_id_))
     return false;
 
-  UpdateDeviceSettings(setting, value, device_settings_);
+  pending_changes_.add(setting, make_scoped_ptr(value.DeepCopy()));
+
+  em::ChromeDeviceSettingsProto settings;
+  if (tentative_settings_.get()) {
+    settings = *tentative_settings_;
+  } else if (device_settings_service_->status() ==
+                 DeviceSettingsService::STORE_SUCCESS &&
+             device_settings_service_->device_settings()) {
+    settings = *device_settings_service_->device_settings();
+  }
+  UpdateDeviceSettings(setting, value, settings);
   em::PolicyData policy_data;
   policy_data.set_username(user_id_);
-  CHECK(device_settings_.SerializeToString(policy_data.mutable_policy_value()));
-  FOR_EACH_OBSERVER(OwnerSettingsService::Observer,
-                    observers_,
+  CHECK(settings.SerializeToString(policy_data.mutable_policy_value()));
+  FOR_EACH_OBSERVER(OwnerSettingsService::Observer, observers_,
                     OnTentativeChangesInPolicy(policy_data));
-  has_pending_changes_ = true;
-  StoreDeviceSettings();
+  StorePendingChanges();
   return true;
 }
 
 bool OwnerSettingsServiceChromeOS::CommitTentativeDeviceSettings(
     scoped_ptr<enterprise_management::PolicyData> policy) {
   if (!IsOwner() && !IsOwnerInTests(user_id_))
     return false;
   if (policy->username() != user_id_) {
     LOG(ERROR) << "Username mismatch: " << policy->username() << " vs. "
                << user_id_;
     return false;
   }
-  CHECK(device_settings_.ParseFromString(policy->policy_value()));
-  FOR_EACH_OBSERVER(OwnerSettingsService::Observer,
-                    observers_,
-                    OnTentativeChangesInPolicy(*policy));
-  has_pending_changes_ = true;
-  StoreDeviceSettings();
+  tentative_settings_.reset(new em::ChromeDeviceSettingsProto);
+  CHECK(tentative_settings_->ParseFromString(policy->policy_value()));
+  StorePendingChanges();
   return true;
 }
 
 void OwnerSettingsServiceChromeOS::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (type != chrome::NOTIFICATION_PROFILE_CREATED) {
     NOTREACHED();
@@ skipping 11 matching lines @@
 }
 
 void OwnerSettingsServiceChromeOS::OwnerKeySet(bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (success)
     ReloadKeypair();
 }
 
 void OwnerSettingsServiceChromeOS::OwnershipStatusChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  StoreDeviceSettings();
+  StorePendingChanges();
 }
 
 void OwnerSettingsServiceChromeOS::DeviceSettingsUpdated() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  StoreDeviceSettings();
+  StorePendingChanges();
 }
 
 void OwnerSettingsServiceChromeOS::OnDeviceSettingsServiceShutdown() {
   device_settings_service_ = nullptr;
 }
 
 // static
 void OwnerSettingsServiceChromeOS::IsOwnerForSafeModeAsync(
     const std::string& user_hash,
     const scoped_refptr<OwnerKeyUtil>& owner_key_util,
@@ skipping 287 matching lines @@
       BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   task_runner->PostTask(
       FROM_HERE,
       base::Bind(&LoadPrivateKey,
                  owner_key_util_,
                  ProfileHelper::GetUserIdHashFromProfile(profile_),
                  callback));
 }
 
-void OwnerSettingsServiceChromeOS::StoreDeviceSettings() {
-  if (!has_pending_changes_ || store_settings_factory_.HasWeakPtrs())
+void OwnerSettingsServiceChromeOS::StorePendingChanges() {
+  if (!has_pending_changes() || store_settings_factory_.HasWeakPtrs() ||
+      !device_settings_service_) {
     return;
-  if (!UpdateFromService())
+  }
+
+  em::ChromeDeviceSettingsProto settings;
+  if (tentative_settings_.get()) {
+    settings.Swap(tentative_settings_.get());
+    tentative_settings_.reset();
+  } else if (device_settings_service_->status() ==
+                 DeviceSettingsService::STORE_SUCCESS &&
+             device_settings_service_->device_settings()) {
+    settings = *device_settings_service_->device_settings();
+  } else {
     return;
+  }
+
+  for (const auto& change : pending_changes_)
+    UpdateDeviceSettings(change.first, *change.second, settings);
+  pending_changes_.clear();
+
   scoped_ptr<em::PolicyData> policy = AssemblePolicy(
-      user_id_, device_settings_service_->policy_data(), &device_settings_);
-  has_pending_changes_ = false;
+      user_id_, device_settings_service_->policy_data(), &settings);
   bool rv = AssembleAndSignPolicyAsync(
-      content::BrowserThread::GetBlockingPool(),
-      policy.Pass(),
+      content::BrowserThread::GetBlockingPool(), policy.Pass(),
       base::Bind(&OwnerSettingsServiceChromeOS::OnPolicyAssembledAndSigned,
                  store_settings_factory_.GetWeakPtr()));
   if (!rv)
     OnSignedPolicyStored(false /* success */);
 }
 
 void OwnerSettingsServiceChromeOS::OnPolicyAssembledAndSigned(
     scoped_ptr<em::PolicyFetchResponse> policy_response) {
   if (!policy_response.get() || !device_settings_service_) {
     OnSignedPolicyStored(false /* success */);
     return;
   }
   device_settings_service_->Store(
       policy_response.Pass(),
       base::Bind(&OwnerSettingsServiceChromeOS::OnSignedPolicyStored,
                  store_settings_factory_.GetWeakPtr(),
                  true /* success */));
 }
 
 void OwnerSettingsServiceChromeOS::OnSignedPolicyStored(bool success) {
   store_settings_factory_.InvalidateWeakPtrs();
   FOR_EACH_OBSERVER(OwnerSettingsService::Observer,
                     observers_,
                     OnSignedPolicyStored(success));
-  StoreDeviceSettings();
-  if (!success)
-    has_pending_changes_ = true;
-}
-
-bool OwnerSettingsServiceChromeOS::UpdateFromService() {
-  if (!device_settings_service_ ||
-      device_settings_service_->status() !=
-          DeviceSettingsService::STORE_SUCCESS ||
-      !device_settings_service_->device_settings()) {
-    return false;
-  }
-  enterprise_management::ChromeDeviceSettingsProto settings =
-      *device_settings_service_->device_settings();
-  settings.MergeFrom(device_settings_);
-  device_settings_.Swap(&settings);
-  return true;
+  StorePendingChanges();
 }
 
 }  // namespace chromeos