Update net/android/network_library.cc with fresher code.

net/android/network_library.cc

 // Copyright (c) 2010 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/android/network_library.h"
 
-#include "base/android/auto_jobject.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
+#include "base/android/scoped_java_ref.h"
 #include "base/logging.h"
 #include "jni/android_network_library_jni.h"
 
 using base::android::AttachCurrentThread;
-using base::android::AutoJObject;
-using base::android::CheckException;
+using base::android::ClearException;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::GetApplicationContext;
+using base::android::ScopedJavaLocalRef;
 using base::android::ToJavaArrayOfByteArray;
 using base::android::ToJavaByteArray;
 
 namespace net {
 namespace android {
 
 VerifyResult VerifyX509CertChain(const std::vector<std::string>& cert_chain,
-                                 const std::string& hostname,
                                  const std::string& auth_type) {
   JNIEnv* env = AttachCurrentThread();
-  if (!env) {
-    // TODO(husky): Maybe initialize the JVM in unit tests?
+  if (!env || !g_AndroidNetworkLibrary_verifyServerCertificates) {
+    // TODO(bulach): Remove when we initialize the JVM in unit tests.
     LOG(WARNING) << "JNI initialization failed";
     return VERIFY_INVOCATION_ERROR;
   }
 
-  AutoJObject chain_byte_array = AutoJObject::FromLocalRef(
-      env, ToJavaArrayOfByteArray(env, cert_chain));
-  DCHECK(chain_byte_array.obj());
+  ScopedJavaLocalRef<jobjectArray> chain_byte_array =
+      ToJavaArrayOfByteArray(env, cert_chain);
+  DCHECK(!chain_byte_array.is_null());
 
-  AutoJObject host_string = AutoJObject::FromLocalRef(
-      env, ConvertUTF8ToJavaString(env, hostname));
-  DCHECK(host_string.obj());
+  ScopedJavaLocalRef<jstring> auth_string =
+      ConvertUTF8ToJavaString(env, auth_type);
+  DCHECK(!auth_string.is_null());
 
-  AutoJObject auth_string = AutoJObject::FromLocalRef(
-      env, ConvertUTF8ToJavaString(env, auth_type));
-  DCHECK(auth_string.obj());
+  jboolean trusted = Java_AndroidNetworkLibrary_verifyServerCertificates(
+      env, chain_byte_array.obj(), auth_string.obj());
+  if (ClearException(env))
+    return VERIFY_INVOCATION_ERROR;
 
-  jint error = Java_AndroidNetworkLibrary_verifyServerCertificates(
-      env, static_cast<jobjectArray>(chain_byte_array.obj()),
-      static_cast<jstring>(host_string.obj()),
-      static_cast<jstring>(auth_string.obj()));
-
-  switch (error) {
-    case 0:
-      return VERIFY_OK;
-    case 1:
-      return VERIFY_BAD_HOSTNAME;
-    case 2:
-      return VERIFY_NO_TRUSTED_ROOT;
-  }
-  return VERIFY_INVOCATION_ERROR;
+  return trusted ? VERIFY_OK : VERIFY_NO_TRUSTED_ROOT;
 }
 
 bool StoreKeyPair(const uint8* public_key,
                   size_t public_len,
                   const uint8* private_key,
                   size_t private_len) {
   JNIEnv* env = AttachCurrentThread();
-  AutoJObject public_array = AutoJObject::FromLocalRef(
-      env, ToJavaByteArray(env, public_key, public_len));
-  AutoJObject private_array = AutoJObject::FromLocalRef(
-      env, ToJavaByteArray(env, private_key, private_len));
+  ScopedJavaLocalRef<jbyteArray> public_array =
+      ToJavaByteArray(env, public_key, public_len);
+  ScopedJavaLocalRef<jbyteArray> private_array =
+      ToJavaByteArray(env, private_key, private_len);
   jboolean ret = Java_AndroidNetworkLibrary_storeKeyPair(env,
-      GetApplicationContext(),
-      static_cast<jbyteArray>(public_array.obj()),
-      static_cast<jbyteArray>(private_array.obj()));
-  if (CheckException(env) || !ret) {
-    LOG(WARNING) << "Call to Java_AndroidNetworkLibrary_storeKeyPair failed";
-    return false;
-  }
-  return true;
+      GetApplicationContext(), public_array.obj(), private_array.obj());
+  LOG_IF(WARNING, !ret) <<
+      "Call to Java_AndroidNetworkLibrary_storeKeyPair failed";
+  return ret;
 }
 
 bool GetMimeTypeFromExtension(const std::string& extension,
                               std::string* result) {
   JNIEnv* env = AttachCurrentThread();
 
-  AutoJObject extension_string = AutoJObject::FromLocalRef(
-      env, ConvertUTF8ToJavaString(env, extension));
-  AutoJObject ret = AutoJObject::FromLocalRef(
-      env, Java_AndroidNetworkLibrary_getMimeTypeFromExtension(
-              env, static_cast<jstring>(extension_string.obj())));
+  ScopedJavaLocalRef<jstring> extension_string =
+      ConvertUTF8ToJavaString(env, extension);
+  ScopedJavaLocalRef<jstring> ret =
+      Java_AndroidNetworkLibrary_getMimeTypeFromExtension(
+          env, extension_string.obj());
 
-  if (CheckException(env) || !ret.obj()) {
+  if (!ret.obj()) {
     LOG(WARNING) << "Call to getMimeTypeFromExtension failed";
     return false;
   }
-  *result = ConvertJavaStringToUTF8(env, static_cast<jstring>(ret.obj()));
+  *result = ConvertJavaStringToUTF8(ret);
   return true;
 }
 
 bool RegisterNetworkLibrary(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 }  // namespace net
-
-