Pass JavaRef to Java methods in net.

net/android/keystore_unittest.cc

 // Copyright (c) 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 <openssl/bn.h>
 #include <openssl/dsa.h>
 #include <openssl/ecdsa.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/pem.h>
@@ skipping 33 matching lines @@
 // possible to create a custom EVP_PKEY that uses
 // RawSignDigestWithPrivateKey() internally to perform RSA/DSA/ECDSA
 // signing, as invoked by the OpenSSL code at
 // openssl/ssl/s3_clnt.c:ssl3_send_client_verify().
 //
 // For more details, read the comments in AndroidKeyStore.java.
 //
 // Finally, it also checks that using the EVP_PKEY generated with
 // GetOpenSSLPrivateKeyWrapper() works correctly.
 
+using base::android::JavaRef;
+
 namespace net {
 namespace android {
 
 namespace {
 
 typedef base::android::ScopedJavaLocalRef<jobject> ScopedJava;
 
 // Returns true if running on an Android version older than 4.2
 bool IsOnAndroidOlderThan_4_2(void) {
   const int kAndroid42ApiLevel = 17;
@@ skipping 284 matching lines @@
   return true;
 }
 
 // Sign a message with our platform API.
 //
 // |android_key| is a JNI reference to the platform PrivateKey object.
 // |openssl_key| is a pointer to an OpenSSL key object for the exact
 // same key content.
 // |message| is a message.
 // |result| will receive the result.
-void DoKeySigning(jobject android_key,
+void DoKeySigning(const JavaRef<jobject>& android_key,
                   EVP_PKEY* openssl_key,
                   const base::StringPiece& message,
                   std::string* result) {
   // First, get the platform signature.
   std::vector<uint8_t> android_signature;
   ASSERT_TRUE(
       RawSignDigestWithPrivateKey(android_key,
                                   message,
                                   &android_signature));
 
@@ skipping 37 matching lines @@
   std::string pkcs8_data;
   ASSERT_TRUE(GetPrivateKeyPkcs8Bytes(pkey, &pkcs8_data));
 
   // Create platform PrivateKey object from it.
   ScopedJava key_java = GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_RSA,
                                                 pkcs8_data);
   ASSERT_FALSE(key_java.is_null());
 
   // Retrieve the corresponding modulus through JNI
   std::vector<uint8_t> modulus_java;
-  ASSERT_TRUE(GetRSAKeyModulus(key_java.obj(), &modulus_java));
+  ASSERT_TRUE(GetRSAKeyModulus(key_java, &modulus_java));
 
   // Create an OpenSSL BIGNUM from it.
   crypto::ScopedBIGNUM bn(
       BN_bin2bn(reinterpret_cast<const unsigned char*>(&modulus_java[0]),
                 static_cast<int>(modulus_java.size()),
                 NULL));
   ASSERT_TRUE(bn.get());
 
   // Compare it to the one in the RSA key, they must be identical.
   crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey.get()));
   ASSERT_TRUE(rsa.get()) << GetOpenSSLErrorString();
 
   ASSERT_EQ(0, BN_cmp(bn.get(), rsa.get()->n));
 }
 
 TEST(AndroidKeyStore,GetPrivateKeyTypeRSA) {
   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 
   ScopedJava rsa_key = GetRSATestKeyJava();
   ASSERT_FALSE(rsa_key.is_null());
-  EXPECT_EQ(PRIVATE_KEY_TYPE_RSA,
-            GetPrivateKeyType(rsa_key.obj()));
+  EXPECT_EQ(PRIVATE_KEY_TYPE_RSA, GetPrivateKeyType(rsa_key));
 }
 
 TEST(AndroidKeyStore,SignWithPrivateKeyRSA) {
   ScopedJava rsa_key = GetRSATestKeyJava();
   ASSERT_FALSE(rsa_key.is_null());
 
   if (IsOnAndroidOlderThan_4_2()) {
     LOG(INFO) << "This test can't run on Android < 4.2";
     return;
   }
 
   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestRsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   std::string message = kTestRsaHash;
   ASSERT_EQ(36U, message.size());
 
   std::string signature;
-  DoKeySigning(rsa_key.obj(), openssl_key.get(), message, &signature);
+  DoKeySigning(rsa_key, openssl_key.get(), message, &signature);
   ASSERT_TRUE(
       CompareSignatureWithOpenSSL(message, signature, openssl_key.get()));
   // All good.
 }
 
 TEST(AndroidKeyStore,SignWithWrapperKeyRSA) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   ScopedJava rsa_key = GetRSATestKeyJava();
   ASSERT_FALSE(rsa_key.is_null());
 
-  crypto::ScopedEVP_PKEY wrapper_key(
-      GetOpenSSLPrivateKeyWrapper(rsa_key.obj()));
+  crypto::ScopedEVP_PKEY wrapper_key(GetOpenSSLPrivateKeyWrapper(rsa_key));
   ASSERT_TRUE(wrapper_key.get() != NULL);
 
   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestRsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   // Check that RSA_size() works properly on the wrapper key.
   EXPECT_EQ(EVP_PKEY_size(openssl_key.get()),
             EVP_PKEY_size(wrapper_key.get()));
 
   // Message size must be 36 for RSA_sign(NID_md5_sha1,...) to return
   // without an error.
   std::string message = kTestRsaHash;
   ASSERT_EQ(36U, message.size());
 
   std::string signature;
   DoKeySigningWithWrapper(wrapper_key.get(),
                           openssl_key.get(),
                           message,
                           &signature);
   ASSERT_TRUE(
       CompareSignatureWithOpenSSL(message, signature, openssl_key.get()));
 }
 
 TEST(AndroidKeyStore,GetPrivateKeyTypeECDSA) {
   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 
   ScopedJava ecdsa_key = GetECDSATestKeyJava();
   ASSERT_FALSE(ecdsa_key.is_null());
-  EXPECT_EQ(PRIVATE_KEY_TYPE_ECDSA,
-            GetPrivateKeyType(ecdsa_key.obj()));
+  EXPECT_EQ(PRIVATE_KEY_TYPE_ECDSA, GetPrivateKeyType(ecdsa_key));
 }
 
 TEST(AndroidKeyStore,SignWithPrivateKeyECDSA) {
   ScopedJava ecdsa_key = GetECDSATestKeyJava();
   ASSERT_FALSE(ecdsa_key.is_null());
 
   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestEcdsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   std::string message = kTestEcdsaHash;
   std::string signature;
-  DoKeySigning(ecdsa_key.obj(), openssl_key.get(), message, &signature);
+  DoKeySigning(ecdsa_key, openssl_key.get(), message, &signature);
   ASSERT_TRUE(VerifyTestECDSASignature(message, signature));
 }
 
 TEST(AndroidKeyStore, SignWithWrapperKeyECDSA) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   ScopedJava ecdsa_key = GetECDSATestKeyJava();
   ASSERT_FALSE(ecdsa_key.is_null());
 
-  crypto::ScopedEVP_PKEY wrapper_key(
-      GetOpenSSLPrivateKeyWrapper(ecdsa_key.obj()));
+  crypto::ScopedEVP_PKEY wrapper_key(GetOpenSSLPrivateKeyWrapper(ecdsa_key));
   ASSERT_TRUE(wrapper_key.get());
 
   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestEcdsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   // Check that ECDSA size works correctly on the wrapper.
   EXPECT_EQ(EVP_PKEY_size(openssl_key.get()),
             EVP_PKEY_size(wrapper_key.get()));
 
   std::string message = kTestEcdsaHash;
   std::string signature;
   DoKeySigningWithWrapper(wrapper_key.get(),
                           openssl_key.get(),
                           message,
                           &signature);
   ASSERT_TRUE(VerifyTestECDSASignature(message, signature));
 }
 
 }  // namespace android
 }  // namespace net