Postpone loading about:flags ui until the certificates have been loaded

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/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 56 matching lines @@
 // static
 DeviceSettingsService* DeviceSettingsService::Get() {
   CHECK(g_device_settings_service);
   return g_device_settings_service;
 }
 
 DeviceSettingsService::DeviceSettingsService()
     : session_manager_client_(NULL),
       weak_factory_(this),
       store_status_(STORE_SUCCESS),
+      certificates_loaded_(false),
+      owner_key_loaded_with_certificates_(false),
       load_retries_left_(kMaxLoadRetries) {
-  if (CertLoader::IsInitialized())
+  if (CertLoader::IsInitialized()) {
+    certificates_loaded_ = CertLoader::Get()->certificates_loaded();
     CertLoader::Get()->AddObserver(this);
+  }
 }
 
 DeviceSettingsService::~DeviceSettingsService() {
   DCHECK(pending_operations_.empty());
   if (CertLoader::IsInitialized())
     CertLoader::Get()->RemoveObserver(this);
 }
 
 void DeviceSettingsService::SetSessionManager(
     SessionManagerClient* session_manager_client,
@@ skipping 59 matching lines @@
 
   return OWNERSHIP_UNKNOWN;
 }
 
 void DeviceSettingsService::GetOwnershipStatusAsync(
     const OwnershipStatusCallback& callback) {
   if (owner_key_.get()) {
     // If there is a key, report status immediately.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   owner_key_->public_key() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE,
-                   owner_key_->private_key() != NULL));
+        base::Bind(
+            callback,
+            owner_key_->public_key() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE));
   } else {
     // If the key hasn't been loaded yet, enqueue the callback to be fired when
     // the next SessionManagerOperation completes. If no operation is pending,
     // start a load operation to fetch the key and report the result.
     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::IsCurrentUserOwnerAsync(
+    const IsCurrentUserOwnerCallback& callback) {
+  if (owner_key_loaded_with_certificates_) {
+    // If the current owner key was loaded while the certificates were loaded,
+    // or the certificate loader is not initialized, in which case the private
+    // key cannot be set, report status immediately.
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, HasPrivateOwnerKey()));
+  } else {
+    // If the key hasn't been loaded with the known certificates, enqueue the
+    // callback to be fired when the next SessionManagerOperation completes in
+    // an environment where the certificates are loaded. There is no need to
+    // start a new operation, as the reload operation will be started when the
+    // certificates are loaded.
+    pending_is_current_user_owner_callbacks_.push_back(callback);
+  }
+}
+
 void DeviceSettingsService::SetUsername(const std::string& username) {
   username_ = username;
 
   // The private key may have become available, so force a key reload.
   owner_key_ = NULL;
   EnsureReload(true);
 }
 
 const std::string& DeviceSettingsService::GetUsername() const {
   return username_;
@@ skipping 22 matching lines @@
     LOG(ERROR) << "Policy update failed.";
     return;
   }
 
   EnsureReload(false);
 }
 
 void DeviceSettingsService::OnCertificatesLoaded(
     const net::CertificateList& cert_list,
     bool initial_load) {
+  certificates_loaded_ = true;
   // CertLoader initializes the TPM and NSS database which is necessary to
   // determine ownership. Force a reload once we know these are initialized.
   EnsureReload(true);
 }
 
 void DeviceSettingsService::Enqueue(SessionManagerOperation* operation) {
   pending_operations_.push_back(operation);
   if (pending_operations_.front() == operation)
     StartNextOperation();
 }
@@ skipping 76 matching lines @@
         content::Source<DeviceSettingsService>(this),
         content::NotificationService::NoDetails());
   }
 
   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);
+    iter->Run(ownership_status);
+  }
+
+  if (certificates_loaded_) {
+    owner_key_loaded_with_certificates_ = true;
+    std::vector<IsCurrentUserOwnerCallback> is_owner_callbacks;
+    is_owner_callbacks.swap(pending_is_current_user_owner_callbacks_);
+    for (std::vector<IsCurrentUserOwnerCallback>::iterator iter(
+             is_owner_callbacks.begin());
+         iter != is_owner_callbacks.end(); ++iter) {
+      iter->Run(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();
 }
 
 ScopedTestDeviceSettingsService::ScopedTestDeviceSettingsService() {
   DeviceSettingsService::Initialize();
 }
 
 ScopedTestDeviceSettingsService::~ScopedTestDeviceSettingsService() {
   DeviceSettingsService::Shutdown();
 }
 
 }  // namespace chromeos