Move crypto files out of base, to a top level directory.

chrome/browser/extensions/extension_creator.cc

 // Copyright (c) 2011 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/extensions/extension_creator.h"
 
 #include <vector>
 #include <string>
 
-#include "base/crypto/rsa_private_key.h"
-#include "base/crypto/signature_creator.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_handle.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/string_util.h"
+#include "crypto/rsa_private_key.h"
+#include "crypto/signature_creator.h"
 #include "chrome/browser/extensions/sandboxed_extension_unpacker.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/zip.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
   const int kRSAKeySize = 1024;
 };
@@ skipping 41 matching lines @@
       extension_file_util::LoadExtension(absolute_extension_dir,
                                          Extension::INTERNAL,
                                          Extension::STRICT_ERROR_CHECKS,
                                          &error_message_));
   if (!extension.get())
     return false;  // LoadExtension already set error_message_.
 
   return true;
 }
 
-base::RSAPrivateKey* ExtensionCreator::ReadInputKey(const FilePath&
+crypto::RSAPrivateKey* ExtensionCreator::ReadInputKey(const FilePath&
     private_key_path) {
   if (!file_util::PathExists(private_key_path)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_NO_EXISTS);
     return NULL;
   }
 
   std::string private_key_contents;
   if (!file_util::ReadFileToString(private_key_path,
       &private_key_contents)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_READ);
     return NULL;
   }
 
   std::string private_key_bytes;
   if (!Extension::ParsePEMKeyBytes(private_key_contents,
        &private_key_bytes)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_INVALID);
     return NULL;
   }
 
-  return base::RSAPrivateKey::CreateFromPrivateKeyInfo(
+  return crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(
       std::vector<uint8>(private_key_bytes.begin(), private_key_bytes.end()));
 }
 
-base::RSAPrivateKey* ExtensionCreator::GenerateKey(const FilePath&
+crypto::RSAPrivateKey* ExtensionCreator::GenerateKey(const FilePath&
     output_private_key_path) {
-  scoped_ptr<base::RSAPrivateKey> key_pair(
-      base::RSAPrivateKey::Create(kRSAKeySize));
+  scoped_ptr<crypto::RSAPrivateKey> key_pair(
+      crypto::RSAPrivateKey::Create(kRSAKeySize));
   if (!key_pair.get()) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_GENERATE);
     return NULL;
   }
 
   std::vector<uint8> private_key_vector;
   if (!key_pair->ExportPrivateKey(&private_key_vector)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_EXPORT);
@@ skipping 37 matching lines @@
   if (!Zip(extension_dir, *zip_path, false)) {  // no hidden files
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_FAILED_DURING_PACKAGING);
     return false;
   }
 
   return true;
 }
 
 bool ExtensionCreator::SignZip(const FilePath& zip_path,
-                               base::RSAPrivateKey* private_key,
+                               crypto::RSAPrivateKey* private_key,
                                std::vector<uint8>* signature) {
-  scoped_ptr<base::SignatureCreator> signature_creator(
-      base::SignatureCreator::Create(private_key));
+  scoped_ptr<crypto::SignatureCreator> signature_creator(
+      crypto::SignatureCreator::Create(private_key));
   ScopedStdioHandle zip_handle(file_util::OpenFile(zip_path, "rb"));
   size_t buffer_size = 1 << 16;
   scoped_array<uint8> buffer(new uint8[buffer_size]);
   int bytes_read = -1;
   while ((bytes_read = fread(buffer.get(), 1, buffer_size,
        zip_handle.get())) > 0) {
     if (!signature_creator->Update(buffer.get(), bytes_read)) {
       error_message_ =
           l10n_util::GetStringUTF8(IDS_EXTENSION_ERROR_WHILE_SIGNING);
       return false;
     }
   }
   zip_handle.Close();
 
   signature_creator->Final(signature);
   return true;
 }
 
 bool ExtensionCreator::WriteCRX(const FilePath& zip_path,
-                                base::RSAPrivateKey* private_key,
+                                crypto::RSAPrivateKey* private_key,
                                 const std::vector<uint8>& signature,
                                 const FilePath& crx_path) {
   if (file_util::PathExists(crx_path))
     file_util::Delete(crx_path, false);
   ScopedStdioHandle crx_handle(file_util::OpenFile(crx_path, "wb"));
 
   std::vector<uint8> public_key;
   if (!private_key->ExportPublicKey(&public_key)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PUBLIC_KEY_FAILED_TO_EXPORT);
@@ skipping 39 matching lines @@
                            const FilePath& crx_path,
                            const FilePath& private_key_path,
                            const FilePath& output_private_key_path) {
   // Check input diretory and read manifest.
   if (!InitializeInput(extension_dir, private_key_path,
                        output_private_key_path)) {
     return false;
   }
 
   // Initialize Key Pair
-  scoped_ptr<base::RSAPrivateKey> key_pair;
+  scoped_ptr<crypto::RSAPrivateKey> key_pair;
   if (!private_key_path.value().empty())
     key_pair.reset(ReadInputKey(private_key_path));
   else
     key_pair.reset(GenerateKey(output_private_key_path));
   if (!key_pair.get())
     return false;
 
   ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDir())
     return false;
 
   // Zip up the extension.
   FilePath zip_path;
   std::vector<uint8> signature;
   bool result = false;
   if (CreateZip(extension_dir, temp_dir.path(), &zip_path) &&
       SignZip(zip_path, key_pair.get(), &signature) &&
       WriteCRX(zip_path, key_pair.get(), signature, crx_path)) {
     result = true;
   }
 
   file_util::Delete(zip_path, false);
   return result;
 }