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

crypto/rsa_private_key_unittest.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 "base/crypto/rsa_private_key.h"

[wtc, 2011/04/07 05:35:53]

It is correct to include "crypto/rsa_private_key.h" first.

 #include "base/memory/scoped_ptr.h"
+#include "crypto/rsa_private_key.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Generate random private keys with two different sizes. Reimport, then
 // export them again. We should get back the same exact bytes.
 TEST(RSAPrivateKeyUnitTest, InitRandomTest) {
-  scoped_ptr<base::RSAPrivateKey> keypair1(base::RSAPrivateKey::Create(1024));
-  scoped_ptr<base::RSAPrivateKey> keypair2(base::RSAPrivateKey::Create(2048));
+  scoped_ptr<crypto::RSAPrivateKey> keypair1(
+      crypto::RSAPrivateKey::Create(1024));
+  scoped_ptr<crypto::RSAPrivateKey> keypair2(
+      crypto::RSAPrivateKey::Create(2048));
   ASSERT_TRUE(keypair1.get());
   ASSERT_TRUE(keypair2.get());
 
   std::vector<uint8> privkey1;
   std::vector<uint8> privkey2;
   std::vector<uint8> pubkey1;
   std::vector<uint8> pubkey2;
 
   ASSERT_TRUE(keypair1->ExportPrivateKey(&privkey1));
   ASSERT_TRUE(keypair2->ExportPrivateKey(&privkey2));
   ASSERT_TRUE(keypair1->ExportPublicKey(&pubkey1));
   ASSERT_TRUE(keypair2->ExportPublicKey(&pubkey2));
 
-  scoped_ptr<base::RSAPrivateKey> keypair3(
-      base::RSAPrivateKey::CreateFromPrivateKeyInfo(privkey1));
-  scoped_ptr<base::RSAPrivateKey> keypair4(
-      base::RSAPrivateKey::CreateFromPrivateKeyInfo(privkey2));
+  scoped_ptr<crypto::RSAPrivateKey> keypair3(
+      crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(privkey1));
+  scoped_ptr<crypto::RSAPrivateKey> keypair4(
+      crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(privkey2));
   ASSERT_TRUE(keypair3.get());
   ASSERT_TRUE(keypair4.get());
 
   std::vector<uint8> privkey3;
   std::vector<uint8> privkey4;
   ASSERT_TRUE(keypair3->ExportPrivateKey(&privkey3));
   ASSERT_TRUE(keypair4->ExportPrivateKey(&privkey4));
 
   ASSERT_EQ(privkey1.size(), privkey3.size());
   ASSERT_EQ(privkey2.size(), privkey4.size());
@@ skipping 111 matching lines @@
     0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18, 
     0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93, 
     0xe7, 0x1f, 0x0f, 0xe6, 0x0f, 0x02, 0x03, 0x01, 
     0x00, 0x01
   };
 
   std::vector<uint8> input;
   input.resize(sizeof(private_key_info));
   memcpy(&input.front(), private_key_info, sizeof(private_key_info));
 
-  scoped_ptr<base::RSAPrivateKey> key(
-      base::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
+  scoped_ptr<crypto::RSAPrivateKey> key(
+      crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
   ASSERT_TRUE(key.get());
 
   std::vector<uint8> output;
   ASSERT_TRUE(key->ExportPublicKey(&output));
 
   ASSERT_TRUE(
       memcmp(expected_public_key_info, &output.front(), output.size()) == 0);
 }
 
 // These two test keys each contain an integer that has 0x00 for its most
@@ skipping 181 matching lines @@
   std::vector<uint8> input2;
 
   input1.resize(sizeof(short_integer_with_high_bit));
   input2.resize(sizeof(short_integer_without_high_bit));
 
   memcpy(&input1.front(), short_integer_with_high_bit,
          sizeof(short_integer_with_high_bit));
   memcpy(&input2.front(), short_integer_without_high_bit,
          sizeof(short_integer_without_high_bit));
 
-  scoped_ptr<base::RSAPrivateKey> keypair1(
-      base::RSAPrivateKey::CreateFromPrivateKeyInfo(input1));
-  scoped_ptr<base::RSAPrivateKey> keypair2(
-      base::RSAPrivateKey::CreateFromPrivateKeyInfo(input2));
+  scoped_ptr<crypto::RSAPrivateKey> keypair1(
+      crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input1));
+  scoped_ptr<crypto::RSAPrivateKey> keypair2(
+      crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input2));
   ASSERT_TRUE(keypair1.get());
   ASSERT_TRUE(keypair2.get());
 
   std::vector<uint8> output1;
   std::vector<uint8> output2;
   ASSERT_TRUE(keypair1->ExportPrivateKey(&output1));
   ASSERT_TRUE(keypair2->ExportPrivateKey(&output2));
 
   ASSERT_EQ(input1.size(), output1.size());
   ASSERT_EQ(input2.size(), output2.size());
   ASSERT_TRUE(0 == memcmp(&output1.front(), &input1.front(),
                           input1.size()));
   ASSERT_TRUE(0 == memcmp(&output2.front(), &input2.front(),
                           input2.size()));
 }