[webcrypto] Fix compiler errors in WebCryptoImplTest

content/renderer/webcrypto/webcrypto_impl_unittest.cc

 // Copyright 2013 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 "webcrypto_impl.h"
+#include "content/renderer/webcrypto/webcrypto_impl.h"
+
+#include <string>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
-#include "content/renderer/webcrypto/webcrypto_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"
 
 namespace {
 
 std::vector<uint8> HexStringToBytes(const std::string& hex) {
   std::vector<uint8> bytes;
@@ skipping 41 matching lines @@
 }
 
 WebKit::WebCryptoAlgorithm CreateAesCbcAlgorithm(
     const std::vector<uint8>& iv) {
   return WebKit::WebCryptoAlgorithm::adoptParamsAndCreate(
       WebKit::WebCryptoAlgorithmIdAesCbc,
       new WebKit::WebCryptoAesCbcParams(Start(iv), iv.size()));
 }
 
 WebKit::WebCryptoAlgorithm CreateAesCbcAlgorithm(
-    unsigned short key_length_bits) {
+    unsigned short key_length_bits) { // NOLINT

[eroman, 2013/11/05 01:06:39]

what is the lint error that this line gives?

   return WebKit::WebCryptoAlgorithm::adoptParamsAndCreate(
       WebKit::WebCryptoAlgorithmIdAesCbc,
       new WebKit::WebCryptoAesKeyGenParams(key_length_bits));
 }
 
 WebKit::WebCryptoAlgorithm CreateRsaAlgorithm(
     WebKit::WebCryptoAlgorithmId algorithm_id,
     unsigned modulus_length,
     const std::vector<uint8>& public_exponent) {
   DCHECK(algorithm_id == WebKit::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
@@ skipping 544 matching lines @@
     if (cipher_text.size() > 3) {
       EXPECT_FALSE(DecryptInternal(CreateAesCbcAlgorithm(iv),
                                    key,
                                    &cipher_text[0],
                                    cipher_text.size() - 3,
                                    &output));
     }
   }
 }
 
-// TODO (padolph): Add test to verify generated symmetric keys appear random.
-
+// TODO(padolph): Add test to verify generated symmetric keys appear random.
 
 TEST_F(WebCryptoImplTest, GenerateKeyAes) {
   WebKit::WebCryptoKey key = WebKit::WebCryptoKey::createNull();
   ASSERT_TRUE(GenerateKeyInternal(CreateAesCbcAlgorithm(128), &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, key.type());
 }
 
 TEST_F(WebCryptoImplTest, GenerateKeyAesBadLength) {
   WebKit::WebCryptoKey key = WebKit::WebCryptoKey::createNull();
@@ skipping 27 matching lines @@
       WebKit::WebCryptoKeyFormatRaw,
       HexStringToBytes("00000000000000000000"),
       WebKit::WebCryptoAlgorithm::createNull(),
       WebKit::WebCryptoKeyUsageSign,
       &key));
 }
 
 #if !defined(USE_OPENSSL)
 
 TEST_F(WebCryptoImplTest, GenerateKeyPairRsa) {
-
   // Note: using unrealistic short key lengths here to avoid bogging down tests.
 
   // Successful WebCryptoAlgorithmIdRsaEsPkcs1v1_5 key generation.
   const unsigned modulus_length = 256;
   const std::vector<uint8> public_exponent = HexStringToBytes("010001");
   WebKit::WebCryptoAlgorithm algorithm =
       CreateRsaAlgorithm(WebKit::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
                          modulus_length,
                          public_exponent);
-  const bool extractable = false;
+  bool extractable = false;
   const WebKit::WebCryptoKeyUsageMask usage_mask = 0;
   WebKit::WebCryptoKey public_key = WebKit::WebCryptoKey::createNull();
   WebKit::WebCryptoKey private_key = WebKit::WebCryptoKey::createNull();
   EXPECT_TRUE(GenerateKeyPairInternal(
       algorithm, extractable, usage_mask, &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(WebKit::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(WebKit::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_EQ(extractable, public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Fail with bad modulus.
   algorithm = CreateRsaAlgorithm(
       WebKit::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, 0, public_exponent);
   EXPECT_FALSE(GenerateKeyPairInternal(
       algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: larger than unsigned long.
-  unsigned exponent_length = sizeof(unsigned long) + 1;
+  unsigned exponent_length = sizeof(unsigned long) + 1; // NOLINT

[eroman, 2013/11/05 01:06:39]

what is the lint error that this line gives?

   const std::vector<uint8> long_exponent(exponent_length, 0x01);
   algorithm = CreateRsaAlgorithm(WebKit::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
                                  modulus_length,
                                  long_exponent);
   EXPECT_FALSE(GenerateKeyPairInternal(
       algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: empty.
   const std::vector<uint8> empty_exponent;
   algorithm = CreateRsaAlgorithm(WebKit::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
@@ skipping 54 matching lines @@
   EXPECT_EQ(WebKit::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_EQ(extractable, public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 }
 
 #endif  // #if !defined(USE_OPENSSL)
 
 }  // namespace content