Implemented profile-aware owner key loading.

chrome/browser/chromeos/settings/session_manager_operation.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/session_manager_operation.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/chromeos/login/user.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/chromeos/settings/owner_key_util.h"
+#include "chrome/browser/net/nss_context.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/rsa_private_key.h"
 #include "crypto/signature_creator.h"
 #include "policy/proto/device_management_backend.pb.h"
 
 namespace em = enterprise_management;
 
 namespace chromeos {
 
+namespace {
+
+Profile* GetProfileByUsername(const std::string& username) {

[Mattias Nissler (ping if slow), 2014/05/13 11:55:53]

No longer needed.

[ygorshenin1, 2014/05/14 09:10:58]

Done.

+  if (!UserManager::IsInitialized())
+    return NULL;
+  UserManager* manager = UserManager::Get();
+  const User* user = manager->FindUser(username);
+  if (!user || !user->is_profile_created())
+    return NULL;
+  return manager->GetProfileByUser(user);
+}
+
+}  // namespace
+
 SessionManagerOperation::SessionManagerOperation(const Callback& callback)
     : session_manager_client_(NULL),
       weak_factory_(this),
       callback_(callback),
       force_key_load_(false),
       is_loading_(false) {}
 
 SessionManagerOperation::~SessionManagerOperation() {}
 
 void SessionManagerOperation::Start(
@@ skipping 29 matching lines @@
 }
 
 void SessionManagerOperation::ReportResult(
     DeviceSettingsService::Status status) {
   callback_.Run(this, status);
 }
 
 void SessionManagerOperation::EnsureOwnerKey(const base::Closure& callback) {
   if (force_key_load_ || !owner_key_.get() || !owner_key_->public_key()) {
     scoped_refptr<base::TaskRunner> task_runner =
-        content::BrowserThread::GetBlockingPool()->
-        GetTaskRunnerWithShutdownBehavior(
-            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+        content::BrowserThread::GetBlockingPool()
+            ->GetTaskRunnerWithShutdownBehavior(
+                base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
     base::PostTaskAndReplyWithResult(
         task_runner.get(),
         FROM_HERE,
         base::Bind(&SessionManagerOperation::LoadOwnerKey,
-                   owner_key_util_, owner_key_),
+                   owner_key_util_,
+                   owner_key_,
+                   slot_),
         base::Bind(&SessionManagerOperation::StoreOwnerKey,
-                   weak_factory_.GetWeakPtr(), callback));
+                   weak_factory_.GetWeakPtr(),
+                   callback));
   } else {
     callback.Run();
   }
 }
 
 // static
 scoped_refptr<OwnerKey> SessionManagerOperation::LoadOwnerKey(
     scoped_refptr<OwnerKeyUtil> util,
-    scoped_refptr<OwnerKey> current_key) {
+    scoped_refptr<OwnerKey> current_key,
+    PK11SlotInfo* slot) {
   scoped_ptr<std::vector<uint8> > public_key;
   scoped_ptr<crypto::RSAPrivateKey> private_key;
 
   // Keep any already-existing keys.
   if (current_key.get()) {
     if (current_key->public_key())
       public_key.reset(new std::vector<uint8>(*current_key->public_key()));
     if (current_key->private_key())
       private_key.reset(current_key->private_key()->Copy());
   }
 
   if (!public_key.get() && util->IsPublicKeyPresent()) {
     public_key.reset(new std::vector<uint8>());
     if (!util->ImportPublicKey(public_key.get()))
       LOG(ERROR) << "Failed to load public owner key.";
   }
 
   if (public_key.get() && !private_key.get()) {
-    private_key.reset(util->FindPrivateKey(*public_key));
+    private_key.reset(util->FindPrivateKeyInSlot(*public_key, slot));
     if (!private_key.get())
       VLOG(1) << "Failed to load private owner key.";
   }
 
   return new OwnerKey(public_key.Pass(), private_key.Pass());
 }
 
 void SessionManagerOperation::StoreOwnerKey(const base::Closure& callback,
                                             scoped_refptr<OwnerKey> new_key) {
   force_key_load_ = false;
@@ skipping 199 matching lines @@
 }
 
 void SignAndStoreSettingsOperation::HandleStoreResult(bool success) {
   if (!success)
     ReportResult(DeviceSettingsService::STORE_OPERATION_FAILED);
   else
     StartLoading();
 }
 
 }  // namespace chromeos