Remove unneeded NSS headers.

chrome/browser/chromeos/login/owner_key_utils.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_key_utils.h"
 
-#include <keyhi.h>     // SECKEY_CreateSubjectPublicKeyInfo()
-#include <pk11pub.h>
-#include <prerror.h>   // PR_GetError()
-#include <secder.h>    // DER_Encode()
-#include <secmod.h>
-
 #include <limits>
 
 #include "base/crypto/rsa_private_key.h"
 #include "base/crypto/signature_creator.h"
 #include "base/crypto/signature_verifier.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/nss_util.h"
 #include "base/nss_util_internal.h"
@@ skipping 71 matching lines @@
 
 // static
 const char OwnerKeyUtilsImpl::kOwnerKeyFile[] = "/var/lib/whitelist/owner.key";
 
 // We're generating and using 2048-bit RSA keys.
 // static
 const uint16 OwnerKeyUtilsImpl::kKeySizeInBits = 2048;
 
 OwnerKeyUtilsImpl::OwnerKeyUtilsImpl() {
   // Ensure NSS is initialized.
   base::EnsureNSSInit();

[wtc, 2010/12/14 21:32:49]

I suspect this base::EnsureNSSInit() call can also be
deleted.  If NSS needs to be initialized, that should be
ensured by the class that calls NSS functions directly
(I guess that would be RSAPrivateKey).

[Chris Masone, 2010/12/14 22:21:53]

That makes sense to me; I wouldn't mind if you took it out while you're here :-)

 }
 
 OwnerKeyUtilsImpl::~OwnerKeyUtilsImpl() {}
 
 RSAPrivateKey* OwnerKeyUtilsImpl::GenerateKeyPair() {
   return RSAPrivateKey::CreateSensitive(kKeySizeInBits);
 }
 
 bool OwnerKeyUtilsImpl::ExportPublicKeyViaDbus(RSAPrivateKey* pair,
                                                LoginLibrary::Delegate* d) {
@@ skipping 32 matching lines @@
     ok = (safe_file_size ==
           file_util::WriteFile(key_file,
                                reinterpret_cast<char*>(&to_export.front()),
                                safe_file_size));
   }
   return ok;
 }
 
 bool OwnerKeyUtilsImpl::ImportPublicKey(const FilePath& key_file,
                                         std::vector<uint8>* output) {
   // Get the file size (must fit in a 32 bit int for NSS).

[wtc, 2010/12/14 21:32:49]

Just wondering: is this because NSS functions use the
'unsigned int' type for buffer lengths?

[Chris Masone, 2010/12/14 22:21:53]

yes

   int64 file_size;
   if (!file_util::GetFileSize(key_file, &file_size)) {
     LOG(ERROR) << "Could not get size of " << key_file.value();
     return false;
   }
   if (file_size > static_cast<int64>(std::numeric_limits<int>::max())) {
     LOG(ERROR) << key_file.value() << "is "
                << file_size << "bytes!!!  Too big!";
     return false;
   }
@@ skipping 37 matching lines @@
 RSAPrivateKey* OwnerKeyUtilsImpl::FindPrivateKey(
     const std::vector<uint8>& key) {
   return RSAPrivateKey::FindFromPublicKeyInfo(key);
 }
 
 FilePath OwnerKeyUtilsImpl::GetOwnerKeyFilePath() {
   return FilePath(OwnerKeyUtilsImpl::kOwnerKeyFile);
 }
 
 }  // namespace chromeos