--- a/widget/android/jni/Accessors.h
+++ b/widget/android/jni/Accessors.h
@@ -6,17 +6,17 @@
 #include "mozilla/jni/Refs.h"
 #include "mozilla/jni/Types.h"
 #include "mozilla/jni/Utils.h"
 #include "AndroidBridge.h"
 
 namespace mozilla {
 namespace jni {
 
-namespace {
+namespace detail {
 
 // Helper class to convert an arbitrary type to a jvalue, e.g. Value(123).val.
 struct Value
 {
     Value(jboolean z) { val.z = z; }
     Value(jbyte b)    { val.b = b; }
     Value(jchar c)    { val.c = c; }
     Value(jshort s)   { val.s = s; }
@@ -24,18 +24,19 @@ struct Value
     Value(jlong j)    { val.j = j; }
     Value(jfloat f)   { val.f = f; }
     Value(jdouble d)  { val.d = d; }
     Value(jobject l)  { val.l = l; }
 
     jvalue val;
 };
 
-}
+} // namespace detail
 
+using namespace detail;
 
 // Base class for Method<>, Field<>, and Constructor<>.
 class Accessor
 {
     static void GetNsresult(JNIEnv* env, nsresult* rv)
     {
         if (env->ExceptionCheck()) {
 #ifdef DEBUG

--- a/widget/android/jni/Natives.h
+++ b/widget/android/jni/Natives.h
@@ -66,19 +66,19 @@ namespace jni {
  *                   instance, mozilla::MakeUnique<MyClass>());
  *
  *           // "instance" owns the newly created C++ object, so the C++
  *           // object is destroyed as soon as instance.dispose() is called.
  *       }
  *   };
  */
 
-namespace {
+namespace detail {
 
-uintptr_t CheckNativeHandle(JNIEnv* env, uintptr_t handle)
+inline uintptr_t CheckNativeHandle(JNIEnv* env, uintptr_t handle)
 {
     if (!handle) {
         if (!env->ExceptionCheck()) {
             ThrowException(env, "java/lang/NullPointerException",
                            "Null native pointer");
         }
         return 0;
     }
@@ -168,17 +168,19 @@ struct NativePtr<Impl, /* UseWeakPtr = *
         if (ptr) {
             SetNativeHandle(instance.Env(), instance.Get(), 0);
             MOZ_CATCH_JNI_EXCEPTION(instance.Env());
             delete ptr;
         }
     }
 };
 
-} // namespace
+} // namespace detail
+
+using namespace detail;
 
 /**
  * For C++ classes whose native methods all return void, they can choose to
  * have the native calls go through a proxy by inheriting from
  * mozilla::jni::UsesNativeCallProxy, and overriding the OnNativeCall member.
  * Subsequently, every native call is automatically wrapped in a functor
  * object, and the object is passed to OnNativeCall. The OnNativeCall
  * implementation can choose to invoke the call, save it, dispatch it to a
@@ -217,20 +219,16 @@ struct UsesNativeCallProxy
     }
 };
 
 namespace detail {
 
 template<class Traits, class Impl, class Args, bool IsStatic, bool IsVoid>
 class NativeStubImpl;
 
-}
-
-namespace {
-
 // ProxyArg is used to handle JNI ref arguments for proxies. Because a proxied
 // call may happen outside of the original JNI native call, we must save all
 // JNI ref arguments as global refs to avoid the arguments going out of scope.
 template<typename T>
 struct ProxyArg
 {
     static_assert(mozilla::IsPod<T>::value, "T must be primitive type");
 
@@ -412,17 +410,17 @@ typename mozilla::EnableIf<
 Dispatch(ProxyNativeCall<Impl, O, S, V, A...>&& call)
 {
     Impl::OnNativeCall(mozilla::Move(call));
 }
 
 template<typename T>
 void Dispatch(const T&) {}
 
-} // namespace
+} // namespace detail
 
 template<class Cls, class Impl> class NativeImpl;
 
 namespace detail {
 
 // Wrapper methods that convert arguments from the JNI types to the native
 // types, e.g. from jobject to jni::Object::Ref. For instance methods, the
 // wrapper methods also convert calls to calls on objects.