html_viewer: Move webcrypto to a place where html_viewer can use it.

components/webcrypto/test/rsa_ssa_unittest.cc

 // Copyright 2014 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/logging.h"
 #include "base/stl_util.h"
-#include "content/child/webcrypto/algorithm_dispatch.h"
-#include "content/child/webcrypto/crypto_data.h"
-#include "content/child/webcrypto/status.h"
-#include "content/child/webcrypto/test/test_helpers.h"
-#include "content/child/webcrypto/webcrypto_util.h"
+#include "components/webcrypto/algorithm_dispatch.h"
+#include "components/webcrypto/crypto_data.h"
+#include "components/webcrypto/status.h"
+#include "components/webcrypto/test/test_helpers.h"
+#include "components/webcrypto/webcrypto_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
-namespace content {
+namespace components {
 
 namespace webcrypto {
 
 namespace {
 
 // Helper for ImportJwkRsaFailures. Restores the JWK JSON
 // dictionary to a good state
 void RestoreJwkRsaDictionary(base::DictionaryValue* dict) {
   dict->Clear();
   dict->SetString("kty", "RSA");
@@ skipping 384 matching lines @@
       blink::WebCryptoAlgorithmIdSha256, modulus_length,
       exponent_with_leading_zeros);
   EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
             GenerateKeyPair(algorithm, extractable, usages, &public_key,
                             &private_key));
 
   // Key generation success using exponent with leading zeros.
   exponent_with_leading_zeros.insert(exponent_with_leading_zeros.end(),
                                      public_exponent.begin(),
                                      public_exponent.end());
-  algorithm =
-      CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                                     blink::WebCryptoAlgorithmIdSha256,
-                                     modulus_length,
-                                     exponent_with_leading_zeros);
+  algorithm = CreateRsaHashedKeyGenAlgorithm(
+      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+      blink::WebCryptoAlgorithmIdSha256, modulus_length,
+      exponent_with_leading_zeros);
   EXPECT_EQ(Status::Success(), GenerateKeyPair(algorithm, extractable, usages,
                                                &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_TRUE(public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(public_usages, public_key.usages());
   EXPECT_EQ(private_usages, private_key.usages());
 
   // Successful WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 key generation (sha1)
-  algorithm =
-      CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                                     blink::WebCryptoAlgorithmIdSha1,
-                                     modulus_length,
-                                     public_exponent);
-  EXPECT_EQ(
-      Status::Success(),
-      GenerateKeyPair(algorithm, false, usages, &public_key, &private_key));
+  algorithm = CreateRsaHashedKeyGenAlgorithm(
+      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+      blink::WebCryptoAlgorithmIdSha1, modulus_length, public_exponent);
+  EXPECT_EQ(Status::Success(), GenerateKeyPair(algorithm, false, usages,
+                                               &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_EQ(modulus_length,
             public_key.algorithm().rsaHashedParams()->modulusLengthBits());
   EXPECT_EQ(modulus_length,
             private_key.algorithm().rsaHashedParams()->modulusLengthBits());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             public_key.algorithm().rsaHashedParams()->hash().id());
@@ skipping 390 matching lines @@
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true, 0, &private_key));
 
   std::vector<uint8_t> public_jwk;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatJwk, public_key, &public_jwk));
 
   ASSERT_EQ(Status::Success(),
-            ImportKey(blink::WebCryptoKeyFormatJwk,
-                      CryptoData(public_jwk),
+            ImportKey(blink::WebCryptoKeyFormatJwk, CryptoData(public_jwk),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha256),
                       true, 0, &public_key));
   EXPECT_EQ(0, public_key.usages());
 
   // With correct usage to get correct imported private_key
   std::vector<uint8_t> private_jwk;
-  ImportKey(blink::WebCryptoKeyFormatPkcs8,
-            CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
-            CreateRsaHashedImportAlgorithm(
-                 blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                 blink::WebCryptoAlgorithmIdSha1),
-            true, blink::WebCryptoKeyUsageSign, &private_key);
+  ImportKey(
+      blink::WebCryptoKeyFormatPkcs8,
+      CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
+      CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                                     blink::WebCryptoAlgorithmIdSha1),
+      true, blink::WebCryptoKeyUsageSign, &private_key);
 
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatJwk, private_key, &private_jwk));
 
   ASSERT_EQ(Status::ErrorCreateKeyEmptyUsages(),
-            ImportKey(blink::WebCryptoKeyFormatJwk,
-                CryptoData(private_jwk),
-                CreateRsaHashedImportAlgorithm(
-                    blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                    blink::WebCryptoAlgorithmIdSha1),
-                true, 0, &private_key));
+            ImportKey(blink::WebCryptoKeyFormatJwk, CryptoData(private_jwk),
+                      CreateRsaHashedImportAlgorithm(
+                          blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                          blink::WebCryptoAlgorithmIdSha1),
+                      true, 0, &private_key));
 }
 
 TEST(WebCryptoRsaSsaTest, ImportExportJwkRsaPublicKey) {
   struct TestCase {
     const blink::WebCryptoAlgorithmId hash;
     const blink::WebCryptoKeyUsageMask usage;
     const char* const jwk_alg;
   };
   const TestCase kTests[] = {
       {blink::WebCryptoAlgorithmIdSha1, blink::WebCryptoKeyUsageVerify, "RS1"},
@@ skipping 149 matching lines @@
                                   blink::WebCryptoAlgorithmIdSha256),
                               true, usages, &key);
     EXPECT_EQ(test_error, StatusToString(status));
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
-}  // namespace content
+}  // namespace components