diff --git a/runtime/native/java_lang_reflect_Constructor.cc b/runtime/native/java_lang_reflect_Constructor.cc
index d28ebd0..2445b53 100644
--- a/runtime/native/java_lang_reflect_Constructor.cc
+++ b/runtime/native/java_lang_reflect_Constructor.cc
@@ -68,7 +68,7 @@
   }
 
   jobject javaReceiver = soa.AddLocalReference<jobject>(receiver);
-  InvokeMethod(soa, javaMethod, javaReceiver, javaArgs, accessible);
+  InvokeMethod(soa, javaMethod, javaReceiver, javaArgs, (accessible == JNI_TRUE));
 
   // Constructors are ()V methods, so we shouldn't touch the result of InvokeMethod.
   return javaReceiver;
diff --git a/runtime/native/java_lang_reflect_Field.cc b/runtime/native/java_lang_reflect_Field.cc
index 755708e..ce622d9 100644
--- a/runtime/native/java_lang_reflect_Field.cc
+++ b/runtime/native/java_lang_reflect_Field.cc
@@ -28,14 +28,14 @@
 
 namespace art {
 
-static bool ValidateFieldAccess(mirror::ArtField* field, mirror::Object* obj, bool is_set)
+static bool VerifyFieldAccess(mirror::ArtField* field, mirror::Object* obj, bool is_set)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (field->IsFinal() && is_set) {
     ThrowIllegalAccessException(nullptr, StringPrintf("Cannot set final field: %s",
                                                       PrettyField(field).c_str()).c_str());
     return false;
   }
-  if (!ValidateAccess(obj, field->GetDeclaringClass(), field->GetAccessFlags())) {
+  if (!VerifyAccess(obj, field->GetDeclaringClass(), field->GetAccessFlags())) {
     ThrowIllegalAccessException(nullptr, StringPrintf("Cannot access field: %s",
                                                       PrettyField(field).c_str()).c_str());
     return false;
@@ -123,8 +123,8 @@
     DCHECK(soa.Self()->IsExceptionPending());
     return nullptr;
   }
-  // Validate access.
-  if (!accessible && !ValidateFieldAccess(f, o, false)) {
+  // If field is not set to be accessible, verify it can be accessed by the caller.
+  if ((accessible == JNI_FALSE) && !VerifyFieldAccess(f, o, false)) {
     DCHECK(soa.Self()->IsExceptionPending());
     return nullptr;
   }
@@ -150,8 +150,8 @@
     return JValue();
   }
 
-  // Validate access.
-  if (!accessible && !ValidateFieldAccess(f, o, false)) {
+  // If field is not set to be accessible, verify it can be accessed by the caller.
+  if ((accessible == JNI_FALSE) && !VerifyFieldAccess(f, o, false)) {
     DCHECK(soa.Self()->IsExceptionPending());
     return JValue();
   }
@@ -291,8 +291,8 @@
     DCHECK(soa.Self()->IsExceptionPending());
     return;
   }
-  // Validate access.
-  if (!accessible && !ValidateFieldAccess(f, o, true)) {
+  // If field is not set to be accessible, verify it can be accessed by the caller.
+  if ((accessible == JNI_FALSE) && !VerifyFieldAccess(f, o, true)) {
     DCHECK(soa.Self()->IsExceptionPending());
     return;
   }
@@ -322,8 +322,8 @@
     return;
   }
 
-  // Validate access.
-  if (!accessible && !ValidateFieldAccess(f, o, true)) {
+  // If field is not set to be accessible, verify it can be accessed by the caller.
+  if ((accessible == JNI_FALSE) && !VerifyFieldAccess(f, o, true)) {
     DCHECK(soa.Self()->IsExceptionPending());
     return;
   }
diff --git a/runtime/native/java_lang_reflect_Method.cc b/runtime/native/java_lang_reflect_Method.cc
index c23f65c..22e81e4 100644
--- a/runtime/native/java_lang_reflect_Method.cc
+++ b/runtime/native/java_lang_reflect_Method.cc
@@ -32,7 +32,7 @@
 static jobject Method_invoke(JNIEnv* env, jobject javaMethod, jobject javaReceiver,
                              jobject javaArgs, jboolean accessible) {
   ScopedFastNativeObjectAccess soa(env);
-  return InvokeMethod(soa, javaMethod, javaReceiver, javaArgs, accessible);
+  return InvokeMethod(soa, javaMethod, javaReceiver, javaArgs, (accessible == JNI_TRUE));
 }
 
 static jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
diff --git a/runtime/reflection.cc b/runtime/reflection.cc
index b38f9b4..6ed61f6 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -500,8 +500,8 @@
     return NULL;
   }
 
-  // Validate access.
-  if (!accessible && !ValidateAccess(receiver, declaring_class, m->GetAccessFlags())) {
+  // If method is not set to be accessible, verify it can be accessed by the caller.
+  if (!accessible && !VerifyAccess(receiver, declaring_class, m->GetAccessFlags())) {
     ThrowIllegalAccessException(nullptr, StringPrintf("Cannot access method: %s",
                                                       PrettyMethod(m).c_str()).c_str());
     return nullptr;
@@ -794,19 +794,19 @@
   return UnboxPrimitive(&throw_location, o, dst_class, nullptr, unboxed_value);
 }
 
-bool ValidateAccess(mirror::Object* obj, mirror::Class* declaring_class, uint32_t access_flags) {
+bool VerifyAccess(mirror::Object* obj, mirror::Class* declaring_class, uint32_t access_flags) {
   NthCallerVisitor visitor(Thread::Current(), 2);
   visitor.WalkStack();
   mirror::Class* caller_class = visitor.caller->GetDeclaringClass();
 
-  if (((access_flags & kAccPublic) && declaring_class->IsPublic()) ||
+  if ((((access_flags & kAccPublic) != 0) && declaring_class->IsPublic()) ||
       caller_class == declaring_class) {
     return true;
   }
-  if (access_flags & kAccPrivate) {
+  if ((access_flags & kAccPrivate) != 0) {
     return false;
   }
-  if (access_flags & kAccProtected) {
+  if ((access_flags & kAccProtected) != 0) {
     if (obj != nullptr && !obj->InstanceOf(caller_class) &&
         !declaring_class->IsInSamePackage(caller_class)) {
       return false;
diff --git a/runtime/reflection.h b/runtime/reflection.h
index 5cc725f..d9a7228 100644
--- a/runtime/reflection.h
+++ b/runtime/reflection.h
@@ -74,7 +74,7 @@
 bool VerifyObjectIsClass(mirror::Object* o, mirror::Class* c)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-bool ValidateAccess(mirror::Object* obj, mirror::Class* declaring_class, uint32_t access_flags)
+bool VerifyAccess(mirror::Object* obj, mirror::Class* declaring_class, uint32_t access_flags)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 }  // namespace art