[Chrome OS] Owner keys are generated outside Chrome now; handle appropriately

chrome/browser/chromeos/cros/login_library.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/cros/login_library.h"
 
 #include "base/message_loop.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/login/signed_settings_temp_storage.h"
+#include "chrome/common/notification_service.h"
+#include "chrome/common/notification_type.h"
 
 namespace chromeos {
 
 class LoginLibraryImpl : public LoginLibrary {
  public:
   LoginLibraryImpl()
       : set_owner_key_callback_(NULL),
         whitelist_op_callback_(NULL),
         property_op_callback_(NULL) {
     if (CrosLibrary::Get()->EnsureLoaded())
@@ skipping 27 matching lines @@
     if (chromeos::RetrievePropertySafe(name.c_str(), &prop)) {
       OUT_value->assign(prop->value);
       CryptoBlob* sig = prop->signature;
       OUT_signature->assign(sig->data, sig->data + sig->length);
       chromeos::FreeProperty(prop);
       return true;
     }
     return false;
   }
 
-  bool SetOwnerKeyAsync(const std::vector<uint8>& public_key_der,
-                        Delegate* callback) {
-    DCHECK(callback) << "must provide a callback to SetOwnerKeyAsync()";
-    if (set_owner_key_callback_)
-      return false;
-    set_owner_key_callback_ =  callback;
-    CryptoBlob* key = chromeos::CreateCryptoBlob(&public_key_der[0],
-                                                 public_key_der.size());
-    bool rv = chromeos::SetOwnerKeySafe(key);
-    chromeos::FreeCryptoBlob(key);
-    return rv;
-  }
-
   bool StorePropertyAsync(const std::string& name,
                           const std::string& value,
                           const std::vector<uint8>& signature,
                           Delegate* callback) {
     DCHECK(callback) << "must provide a callback to StorePropertyAsync()";
     if (property_op_callback_)
       return false;
     property_op_callback_ = callback;
     Property* prop = chromeos::CreateProperty(name.c_str(),
                                               value.c_str(),
@@ skipping 87 matching lines @@
       default:
         NOTREACHED();
         break;
     }
   }
 
   void Init() {
     session_connection_ = chromeos::MonitorSession(&Handler, this);
   }
 
-  void CompleteSetOwnerKey(bool result) {
-    if (set_owner_key_callback_) {
-      set_owner_key_callback_->OnComplete(result);
-      set_owner_key_callback_ = NULL;
+  void CompleteSetOwnerKey(bool value) {
+    VLOG(1) << "Owner key generation: " << (value ? "success" : "fail");
+    NotificationType result =
+        NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED;
+    if (!value)
+      result = NotificationType::OWNER_KEY_FETCH_ATTEMPT_FAILED;
+
+    // Whether we exported the public key or not, send a notification indicating
+    // that we're done with this attempt.
+    NotificationService::current()->Notify(result,
+                                           NotificationService::AllSources(),
+                                           NotificationService::NoDetails());
+
+    // We stored some settings in transient storage before owner was assigned.
+    // Now owner is assigned and key is generated and we should persist
+    // those settings into signed storage.
+    if (g_browser_process && g_browser_process->local_state()) {
+      SignedSettingsTempStorage::Finalize(g_browser_process->local_state());
     }
   }
 
   void CompleteWhitelistOp(bool result) {
     if (whitelist_op_callback_) {
       whitelist_op_callback_->OnComplete(result);
       whitelist_op_callback_ = NULL;
     }
   }
 
@@ skipping 24 matching lines @@
     OUT_signature->assign(2, 0);
     return true;
   }
   bool RetrieveProperty(const std::string& name,
                         std::string* OUT_value,
                         std::vector<uint8>* OUT_signature) {
     OUT_value->assign("stub");
     OUT_signature->assign(2, 0);
     return true;
   }
-  bool SetOwnerKeyAsync(const std::vector<uint8>& public_key_der,
-                        Delegate* callback) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        NewRunnableFunction(&DoStubCallback, callback));
-    return true;
-  }
   bool StorePropertyAsync(const std::string& name,
                           const std::string& value,
                           const std::vector<uint8>& signature,
                           Delegate* callback) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableFunction(&DoStubCallback, callback));
     return true;
   }
   bool UnwhitelistAsync(const std::string& email,
@@ skipping 31 matching lines @@
 
 // static
 LoginLibrary* LoginLibrary::GetImpl(bool stub) {
   if (stub)
     return new LoginLibraryStubImpl();
   else
     return new LoginLibraryImpl();
 }
 
 }  // namespace chromeos