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

net/base/keygen_handler_win.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 "net/base/keygen_handler.h"
 
 #include <windows.h>
 #include <wincrypt.h>
 #pragma comment(lib, "crypt32.lib")
 #include <rpc.h>
 #pragma comment(lib, "rpcrt4.lib")
 
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
-#include "base/crypto/capi_util.h"
-#include "base/crypto/scoped_capi_types.h"
 #include "base/logging.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "crypto/capi_util.h"
+#include "crypto/scoped_capi_types.h"
+
 
 namespace net {
 
 // Assigns the contents of a CERT_PUBLIC_KEY_INFO structure for the signing
 // key in |prov| to |output|. Returns true if encoding was successful.
 bool GetSubjectPublicKeyInfo(HCRYPTPROV prov, std::vector<BYTE>* output) {
   BOOL ok;
   DWORD size = 0;
 
   // From the private key stored in HCRYPTPROV, obtain the public key, stored
@@ skipping 101 matching lines @@
 struct KeyContainer {
  public:
   explicit KeyContainer(bool delete_keyset)
       : delete_keyset_(delete_keyset) {}
 
   ~KeyContainer() {
     if (provider_) {
       provider_.reset();
       if (delete_keyset_ && !key_id_.empty()) {
         HCRYPTPROV provider;
-        base::CryptAcquireContextLocked(&provider, key_id_.c_str(), NULL,
+        crypto::CryptAcquireContextLocked(&provider, key_id_.c_str(), NULL,
             PROV_RSA_FULL, CRYPT_SILENT | CRYPT_DELETEKEYSET);
       }
     }
   }
 
-  base::ScopedHCRYPTPROV provider_;
+  crypto::ScopedHCRYPTPROV provider_;
   std::wstring key_id_;
 
  private:
   bool delete_keyset_;
 };
 
 std::string KeygenHandler::GenKeyAndSignChallenge() {
   KeyContainer key_container(!stores_key_);
 
   // TODO(rsleevi): Have the user choose which provider they should use, which
   // needs to be filtered by those providers which can provide the key type
   // requested or the key size requested. This is especially important for
   // generating certificates that will be stored on smart cards.
   const int kMaxAttempts = 5;
   int attempt;
   for (attempt = 0; attempt < kMaxAttempts; ++attempt) {
     // Per MSDN documentation for CryptAcquireContext, if applications will be
     // creating their own keys, they should ensure unique naming schemes to
     // prevent overlap with any other applications or consumers of CSPs, and
     // *should not* store new keys within the default, NULL key container.
     key_container.key_id_ = GetNewKeyContainerId();
     if (key_container.key_id_.empty())
       return std::string();
 
     // Only create new key containers, so that existing key containers are not
     // overwritten.
-    if (base::CryptAcquireContextLocked(key_container.provider_.receive(),
-        key_container.key_id_.c_str(), NULL, PROV_RSA_FULL,
-        CRYPT_SILENT | CRYPT_NEWKEYSET))
+    if (crypto::CryptAcquireContextLocked(key_container.provider_.receive(),
+            key_container.key_id_.c_str(), NULL, PROV_RSA_FULL,
+            CRYPT_SILENT | CRYPT_NEWKEYSET))
       break;
 
     if (GetLastError() != NTE_BAD_KEYSET) {
       LOG(ERROR) << "Keygen failed: Couldn't acquire a CryptoAPI provider "
                     "context: " << GetLastError();
       return std::string();
     }
   }
   if (attempt == kMaxAttempts) {
     LOG(ERROR) << "Keygen failed: Couldn't acquire a CryptoAPI provider "
                   "context: Max retries exceeded";
     return std::string();
   }
 
   {
-    base::ScopedHCRYPTKEY key;
+    crypto::ScopedHCRYPTKEY key;
     if (!CryptGenKey(key_container.provider_, CALG_RSA_KEYX,
         (key_size_in_bits_ << 16) | CRYPT_EXPORTABLE, key.receive())) {
       LOG(ERROR) << "Keygen failed: Couldn't generate an RSA key";
       return std::string();
     }
 
     std::string spkac;
     if (!GetSignedPublicKeyAndChallenge(key_container.provider_, challenge_,
                                         &spkac)) {
       LOG(ERROR) << "Keygen failed: Couldn't generate the signed public key "
                     "and challenge";
       return std::string();
     }
 
     std::string result;
     if (!base::Base64Encode(spkac, &result)) {
       LOG(ERROR) << "Keygen failed: Couldn't convert signed key into base64";
       return std::string();
     }
 
     VLOG(1) << "Keygen succeeded";
     return result;
   }
 }
 
 }  // namespace net