[Chrome OS] Wire up ownership API from libcros

chrome/browser/chromeos/login/owner_manager.cc

 // Copyright (c) 2010 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/login/owner_manager.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 
 namespace chromeos {
 
 OwnerManager::OwnerManager()
     : private_key_(NULL),
       public_key_(NULL),
       utils_(OwnerKeyUtils::Create()) {
 }
 
 OwnerManager::~OwnerManager() {}
 
-bool OwnerManager::IsAlreadyOwned() {
-  return file_util::PathExists(utils_->GetOwnerKeyFilePath());
-}
-
-bool OwnerManager::StartLoadOwnerKeyAttempt() {
-  if (!IsAlreadyOwned()) {
-    LOG(ERROR) << "Device not yet owned";
-    return false;
-  }
-  ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &OwnerManager::LoadOwnerKey));
-  return true;
-}
-
-bool OwnerManager::StartTakeOwnershipAttempt() {
-  if (IsAlreadyOwned()) {
-    LOG(ERROR) << "Device is already owned";
-    return false;
-  }
-  ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &OwnerManager::GenerateKeysAndExportPublic));
-  return true;
-}
-
-bool OwnerManager::StartSigningAttempt(const std::string& data, Delegate* d) {
-  if (!IsAlreadyOwned()) {
-    LOG(ERROR) << "Device not yet owned";
-    return false;
-  }
-  ChromeThread::ID thread_id;
-  if (!ChromeThread::GetCurrentThreadIdentifier(&thread_id))
-    thread_id = ChromeThread::UI;
-  ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &OwnerManager::Sign, thread_id, data, d));
-  return true;
-}
-
-bool OwnerManager::StartVerifyAttempt(const std::string& data,
-                                      const std::string& signature,
-                                      Delegate* d) {
-  if (!IsAlreadyOwned()) {
-    LOG(ERROR) << "Device not yet owned";
-    return false;
-  }
-  ChromeThread::ID thread_id;
-  if (!ChromeThread::GetCurrentThreadIdentifier(&thread_id))
-    thread_id = ChromeThread::UI;
-  ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
-      NewRunnableMethod(this,
-                        &OwnerManager::Verify,
-                        thread_id,
-                        data,
-                        signature,
-                        d));
-  return true;
-}
-
 void OwnerManager::LoadOwnerKey() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   NotificationType result = NotificationType::OWNER_KEY_FETCH_ATTEMPT_FAILED;
   if (utils_->ImportPublicKey(utils_->GetOwnerKeyFilePath(), &public_key_))
     result = NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED;
 
   // Whether we loaded the public key or not, send a notification indicating
   // that we're done with this attempt.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
@@ skipping 19 matching lines @@
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &OwnerManager::SendNotification,
                           result,
                           NotificationService::NoDetails()));
   }
 }
 
 void OwnerManager::ExportKey() {
+  if (!utils_->ExportPublicKeyViaDbus(private_key_.get(), this)) {
+    private_key_.reset(NULL);
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(this,
+                          &OwnerManager::SendNotification,
+                          NotificationType::OWNER_KEY_FETCH_ATTEMPT_FAILED,
+                          NotificationService::NoDetails()));
+  }
+}
+
+void OwnerManager::Run(bool value) {
   NotificationType result = NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED;
-  if (!utils_->ExportPublicKeyViaDbus(private_key_.get())) {
-    private_key_.reset(NULL);
+  if (!value)
     result = NotificationType::OWNER_KEY_FETCH_ATTEMPT_FAILED;
-  }
 
-  // Whether we generated the keys or not, send a notification indicating
+  // Whether we exported the public key or not, send a notification indicating
   // that we're done with this attempt.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this,
                         &OwnerManager::SendNotification,
                         result,
                         NotificationService::NoDetails()));
+
 }
 
 bool OwnerManager::EnsurePublicKey() {
   if (public_key_.empty())
     LoadOwnerKey();
 
   return !public_key_.empty();
 }
 
 bool OwnerManager::EnsurePrivateKey() {
@@ skipping 57 matching lines @@
 
 void OwnerManager::SendNotification(NotificationType type,
                                     const NotificationDetails& details) {
     NotificationService::current()->Notify(
         type,
         NotificationService::AllSources(),
         details);
 }
 
 }  // namespace chromeos