Add DeviceSettingsService.

chrome/browser/chromeos/settings/device_settings_service.cc

+// Copyright (c) 2012 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/settings/device_settings_service.h"
+
+#include "base/bind.h"
+#include "base/file_util.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/stl_util.h"
+#include "chrome/browser/chromeos/settings/owner_key_util.h"
+#include "chrome/browser/chromeos/settings/session_manager_operation.h"
+#include "chrome/browser/policy/proto/chrome_device_policy.pb.h"
+#include "chrome/browser/policy/proto/device_management_backend.pb.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "crypto/rsa_private_key.h"
+
+namespace em = enterprise_management;
+
+namespace chromeos {
+
+static base::LazyInstance<DeviceSettingsService> g_device_settings_service =

[Chris Masone, 2012/08/03 16:28:25]

There was recently a thread about making all these 'Leaky', wasn't there?  Do we
need to do anything special to make that happen, or has it been made the default
now?  It seems safe for this LazyInstance to leak at shutdown, as it doesn't
need to do any cleanup.

[Mattias Nissler (ping if slow), 2012/08/06 21:28:14]

I think you're referring to this thread:
https://groups.google.com/a/chromium.org/d/topic/chromium-dev/JsPbr3UngS4/dis...

Since I don't specify the singleton traits explicitly, this should be perfectly
good when the traits switch to leaky by default.

+    LAZY_INSTANCE_INITIALIZER;
+
+OwnerKey::OwnerKey(scoped_ptr<std::vector<uint8> > public_key,
+                   scoped_ptr<crypto::RSAPrivateKey> private_key)
+    : public_key_(public_key.Pass()),
+      private_key_(private_key.Pass()) {}
+
+OwnerKey::~OwnerKey() {}
+
+DeviceSettingsService::Observer::~Observer() {}
+
+DeviceSettingsService::DeviceSettingsService()
+    : session_manager_client_(NULL),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+      store_status_(STORE_SUCCESS),
+      ownership_status_(OWNERSHIP_UNKNOWN) {}
+
+DeviceSettingsService::~DeviceSettingsService() {
+  DCHECK(pending_operations_.empty());
+}
+
+// static
+DeviceSettingsService* DeviceSettingsService::Get() {
+  return g_device_settings_service.Pointer();
+}
+
+void DeviceSettingsService::Initialize(
+    SessionManagerClient* session_manager_client,
+    scoped_refptr<OwnerKeyUtil> owner_key_util) {
+  DCHECK(session_manager_client);
+  DCHECK(owner_key_util.get());
+  DCHECK(!session_manager_client_);
+  DCHECK(!owner_key_util_.get());
+
+  session_manager_client_ = session_manager_client;
+  owner_key_util_ = owner_key_util;
+
+  session_manager_client_->AddObserver(this);
+
+  StartNextOperation();
+}
+
+void DeviceSettingsService::Shutdown() {
+  STLDeleteContainerPointers(pending_operations_.begin(),
+                             pending_operations_.end());
+  pending_operations_.clear();
+
+  session_manager_client_->RemoveObserver(this);
+  session_manager_client_ = NULL;
+  owner_key_util_ = NULL;
+}
+
+scoped_refptr<OwnerKey> DeviceSettingsService::GetOwnerKey() {
+  return owner_key_;
+}
+
+void DeviceSettingsService::Load() {
+  EnqueueLoad(false);
+}
+
+void DeviceSettingsService::SignAndStore(
+    scoped_ptr<em::ChromeDeviceSettingsProto> settings,

[Chris Masone, 2012/08/03 16:28:25]

IF this class is holding this settings proto, why is one passed in here?

[Mattias Nissler (ping if slow), 2012/08/06 21:28:14]

It holds the current settings proto. The one passed here is the update that's
supposed to be signed and sent to session manager, then reloaded, verified and
eventually to become the new settings proto. I changed the name to new_settings
to make it clearer.

+    const base::Closure& callback) {
+  Enqueue(
+      new SignAndStoreSettingsOperation(
+          base::Bind(&DeviceSettingsService::HandleCompletedOperation,
+                     weak_factory_.GetWeakPtr(),
+                     callback),
+          settings.Pass(),
+          username_));
+}
+
+void DeviceSettingsService::Store(const std::string& policy_blob,
+                                  const base::Closure& callback) {
+  Enqueue(
+      new StoreSettingsOperation(
+          base::Bind(&DeviceSettingsService::HandleCompletedOperation,
+                     weak_factory_.GetWeakPtr(),
+                     callback),
+          policy_blob));
+}
+
+DeviceSettingsService::OwnershipStatus
+    DeviceSettingsService::GetOwnershipStatus(bool blocking) {
+  OwnershipStatus status = OWNERSHIP_UNKNOWN;
+  bool is_owned = false;
+  if (content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
+    ownership_status_lock_.Acquire();

[Chris Masone, 2012/08/03 16:28:25]

I always liked AutoLock() for this stuff.

{
  AutoLock scoped_lock(ownership_status_lock_);
  status = ownership_status_;
}

[Mattias Nissler (ping if slow), 2012/08/06 21:28:14]

Done. This function is actually copied legacy code, and I'm hoping to get rid of
it soonish.

+    status = ownership_status_;
+    ownership_status_lock_.Release();
+    if (status != OWNERSHIP_UNKNOWN || !blocking)
+      return status;
+    // Under common usage there is very short lapse of time when ownership
+    // status is still unknown after constructing DeviceSettingsService.
+    LOG(ERROR) << "Blocking on UI thread in DeviceSettingsService::GetStatus";
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    is_owned = owner_key_util_->IsPublicKeyPresent();
+  } else {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+    is_owned = owner_key_util_->IsPublicKeyPresent();
+  }
+  status = is_owned ? OWNERSHIP_TAKEN : OWNERSHIP_NONE;
+  SetOwnershipStatus(status);
+  return status;
+}
+
+void DeviceSettingsService::GetOwnershipStatusAsync(

[Chris Masone, 2012/08/03 16:28:25]

it seems like the semantics of this and the above differ, beyond the obvious
sync/async.  The above code says OWNERSHIP_TAKEN if the public key file is
present on disk, and this one says OWNERSHIP_TAKEN if the public key has been
loaded into owner_key_.

[Mattias Nissler (ping if slow), 2012/08/06 21:28:14]

True. As commented above, the blocking and locking was meant to go away in any
case, so I've just done that now.

+    const OwnershipStatusCallback& callback) {
+  if (owner_key_.get()) {
+    // If there is a key, report status immediately.
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   owner_key_->public_key() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE,
+                   owner_key_->private_key()));

[Chris Masone, 2012/08/03 16:28:25]

Hm.  The level of abstraction between this point of call and the actual
definition of an OwnershipStatusCallback makes it hard to remember that this
isn't actually passing the private key around here.  I understand that it gets
coerced to a bool, but it might be nice to put a '!= NULL' just to make it
obvious

[Mattias Nissler (ping if slow), 2012/08/06 21:28:14]

Totally agree. Done.

+  } else {
+    // If the key hasn't been loaded yet, trigger a policy load operation or
+    // wait for an existing operation to finish.

[Chris Masone, 2012/08/03 16:28:25]

Well...you don't wait for an existing operation to finish, do you?  If there are
any existing operations, you just don't EnqueueLoad().  In that case, it's up to
the caller to try again later, yes?  What if the pending operation is not a
load?

[Mattias Nissler (ping if slow), 2012/08/06 21:28:14]

Every operation returns the current key status. So if there already is one
pending operation, it will invoke all pending callbacks on completion. I
clarified the comment.

+    pending_ownership_status_callbacks_.push_back(callback);
+    if (pending_operations_.empty())
+      EnqueueLoad(false);
+  }
+}
+
+bool DeviceSettingsService::HasPrivateOwnerKey() {
+  return owner_key_.get() && owner_key_->private_key();
+}
+
+void DeviceSettingsService::SetUsername(const std::string& username) {
+  username_ = username;
+
+  // The private key may have become available, so force a key reload.

[Chris Masone, 2012/08/03 16:28:25]

How does this follow?

[Mattias Nissler (ping if slow), 2012/08/06 21:28:14]

We throw away the old key, so the next operation that runs will have to re-check
the disk. I've now made this explicit here instead of piggybacking on
OwnerKeySet().

+  OwnerKeySet(true);
+}
+
+const std::string& DeviceSettingsService::GetUsername() const {
+  return username_;
+}
+
+void DeviceSettingsService::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void DeviceSettingsService::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void DeviceSettingsService::OwnerKeySet(bool success) {
+  if (!success) {
+    LOG(ERROR) << "Owner key change failed.";
+    return;
+  }
+
+  owner_key_ = NULL;
+  EnsureReload(true);
+}
+
+void DeviceSettingsService::PropertyChangeComplete(bool success) {
+  if (!success) {
+    LOG(ERROR) << "Policy update failed.";
+    return;
+  }
+
+  EnsureReload(false);
+}
+
+void DeviceSettingsService::Enqueue(SessionManagerOperation* operation) {
+  pending_operations_.push_back(operation);
+  if (pending_operations_.front() == operation)
+    StartNextOperation();
+}
+
+void DeviceSettingsService::EnqueueLoad(bool force_key_load) {
+  SessionManagerOperation* operation =
+      new LoadSettingsOperation(
+          base::Bind(&DeviceSettingsService::HandleCompletedOperation,
+                     weak_factory_.GetWeakPtr(),
+                     base::Closure()));
+  operation->set_force_key_load(force_key_load);
+  Enqueue(operation);
+}
+
+void DeviceSettingsService::EnsureReload(bool force_key_load) {
+  if (!pending_operations_.empty())
+    pending_operations_.front()->RestartLoad(force_key_load);
+  else
+    EnqueueLoad(force_key_load);
+}
+
+void DeviceSettingsService::StartNextOperation() {
+  if (!pending_operations_.empty() &&
+      session_manager_client_ &&
+      owner_key_util_.get()) {
+    pending_operations_.front()->Start(session_manager_client_,
+                                       owner_key_util_, owner_key_);
+  }
+}
+
+void DeviceSettingsService::HandleCompletedOperation(
+    const base::Closure& callback,
+    SessionManagerOperation* operation,
+    Status status) {
+  DCHECK_EQ(operation, pending_operations_.front());
+  store_status_ = status;
+
+  OwnershipStatus ownership_status = OWNERSHIP_UNKNOWN;
+  bool is_owner = false;
+  scoped_refptr<OwnerKey> new_key(operation->owner_key());
+  if (new_key.get()) {
+    ownership_status =
+        new_key->public_key() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE;
+    is_owner = (new_key->private_key() != NULL);
+  } else {
+    NOTREACHED() << "Failed to determine key status.";
+  }
+  SetOwnershipStatus(ownership_status);
+
+  if (owner_key_.get() != new_key.get()) {
+    owner_key_ = new_key;
+    FOR_EACH_OBSERVER(Observer, observers_, OwnershipStatusChanged());
+    content::NotificationService::current()->Notify(
+        chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED,
+        content::Source<DeviceSettingsService>(this),
+        content::NotificationService::NoDetails());
+  }
+
+  if (status == STORE_SUCCESS) {
+    policy_data_ = operation->policy_data().Pass();
+    device_settings_ = operation->device_settings().Pass();
+  } else if (status != STORE_KEY_UNAVAILABLE) {
+    LOG(ERROR) << "Session manager operation failed: " << status;
+  }
+
+  FOR_EACH_OBSERVER(Observer, observers_, DeviceSettingsUpdated());
+
+  std::vector<OwnershipStatusCallback> callbacks;
+  callbacks.swap(pending_ownership_status_callbacks_);
+  for (std::vector<OwnershipStatusCallback>::iterator iter(callbacks.begin());
+       iter != callbacks.end(); ++iter) {
+    iter->Run(ownership_status, is_owner);
+  }
+
+  // The completion callback happens after the notification so clients can
+  // filter self-triggered updates.
+  if (!callback.is_null())
+    callback.Run();
+
+  // Only remove the pending operation here, so new operations triggered by any
+  // of the callbacks above are queued up properly.
+  pending_operations_.pop_front();
+  delete operation;
+
+  StartNextOperation();
+}
+
+void DeviceSettingsService::SetOwnershipStatus(OwnershipStatus new_status) {
+  DCHECK(new_status == OWNERSHIP_TAKEN || new_status == OWNERSHIP_NONE);
+  base::AutoLock lk(ownership_status_lock_);
+  ownership_status_ = new_status;
+}
+
+}  // namespace chromeos