Global Metrics

Spaces Data

Minimal test - lines (19, 1014)

Code

namespace mozilla {
namespace jni {

// Wrapped object reference (e.g. jobject, jclass, etc...)
template 
class Ref;
// Represents a calling context for JNI methods.
template 
class Context;
// Wrapped local reference that inherits from Ref.
template 
class LocalRef;
// Wrapped global reference that inherits from Ref.
template 
class GlobalRef;
// Wrapped weak reference that inherits from Ref.
template 
class WeakRef;
// Wrapped dangling reference that's owned by someone else.
template 
class DependentRef;

// Class to hold the native types of a method's arguments.
// For example, if a method has signature (ILjava/lang/String;)V,
// its arguments class would be jni::Args
template 
struct Args {};

class Object;

// Base class for Ref and its specializations.
template 
class Ref {
  template 
  friend class Ref;

  using Self = Ref;
  using bool_type = void (Self::*)() const;
  void non_null_reference() const {}

  // A Cls-derivative that allows copying
  // (e.g. when acting as a return value).
  struct CopyableCtx : public Context {
    CopyableCtx(JNIEnv* env, Type instance)
        : Context(env, instance) {}

    CopyableCtx(const CopyableCtx& cls)
        : Context(cls.Env(), cls.Get()) {}
  };

  // Private copy constructor so that there's no danger of assigning a
  // temporary LocalRef/GlobalRef to a Ref, and potentially use the Ref
  // after the source had been freed.
  Ref(const Ref&) = default;

 protected:
  static JNIEnv* FindEnv() {
    return Cls::callingThread == CallingThread::GECKO ? GetGeckoThreadEnv()
                                                      : GetEnvForThread();
  }

  Type mInstance;

  // Protected jobject constructor because outside code should be using
  // Ref::From. Using Ref::From makes it very easy to see which code is using
  // raw JNI types for future refactoring.
  explicit Ref(Type instance) : mInstance(instance) {}

 public:
  using JNIType = Type;

  class AutoLock {
    friend class Ref;

    JNIEnv* const mEnv;
    Type mInstance;

    explicit AutoLock(Type aInstance)
        : mEnv(FindEnv()), mInstance(mEnv->NewLocalRef(aInstance)) {
      mEnv->MonitorEnter(mInstance);
      MOZ_CATCH_JNI_EXCEPTION(mEnv);
    }

   public:
    AutoLock(AutoLock&& aOther)
        : mEnv(aOther.mEnv), mInstance(aOther.mInstance) {
      aOther.mInstance = nullptr;
    }

    ~AutoLock() { Unlock(); }

    void Unlock() {
      if (mInstance) {
        mEnv->MonitorExit(mInstance);
        mEnv->DeleteLocalRef(mInstance);
        MOZ_CATCH_JNI_EXCEPTION(mEnv);
        mInstance = nullptr;
      }
    }
  };

  // Construct a Ref form a raw JNI reference.
  static Ref From(JNIType obj) { return Ref(obj); }

  // Construct a Ref form a generic object reference.
  static Ref From(const Ref& obj) {
    return Ref(JNIType(obj.Get()));
  }

  MOZ_IMPLICIT Ref(decltype(nullptr)) : mInstance(nullptr) {}

  // Get the raw JNI reference.
  JNIType Get() const { return mInstance; }

  template 
  bool IsInstanceOf() const {
    return FindEnv()->IsInstanceOf(mInstance, typename T::Context().ClassRef());
  }

  template 
  typename T::Ref Cast() const {
#ifdef MOZ_CHECK_JNI
    MOZ_RELEASE_ASSERT(FindEnv()->IsAssignableFrom(
        Context().ClassRef(), typename T::Context().ClassRef()));
#endif
    return T::Ref::From(*this);
  }

  AutoLock Lock() const { return AutoLock(mInstance); }

  bool operator==(const Ref& other) const {
    // Treat two references of the same object as being the same.
    return mInstance == other.mInstance ||
           JNI_FALSE != FindEnv()->IsSameObject(mInstance, other.mInstance);
  }

  bool operator!=(const Ref& other) const { return !operator==(other); }

  bool operator==(decltype(nullptr)) const { return !mInstance; }

  bool operator!=(decltype(nullptr)) const { return !!mInstance; }

  CopyableCtx operator->() const { return CopyableCtx(FindEnv(), mInstance); }

  CopyableCtx operator*() const { return operator->(); }

  // Any ref can be cast to an object ref.
  operator Ref() const {
    return Ref(mInstance);
  }

  // Null checking (e.g. !!ref) using the safe-bool idiom.
  operator bool_type() const {
    return mInstance ? &Self::non_null_reference : nullptr;
  }

  // We don't allow implicit conversion to jobject because that can lead
  // to easy mistakes such as assigning a temporary LocalRef to a jobject,
  // and using the jobject after the LocalRef has been freed.

  // We don't allow explicit conversion, to make outside code use Ref::Get.
  // Using Ref::Get makes it very easy to see which code is using raw JNI
  // types to make future refactoring easier.

  // operator JNIType() const = delete;
};

// Represents a calling context for JNI methods.
template 
class Context : public Ref {
  using Ref = jni::Ref;

  static jclass sClassRef;  // global reference

 protected:
  JNIEnv* const mEnv;

 public:
  Context() : Ref(nullptr), mEnv(Ref::FindEnv()) {}

  Context(JNIEnv* env, Type instance) : Ref(instance), mEnv(env) {}

  jclass ClassRef() const {
    if (!sClassRef) {
      const jclass cls = GetClassRef(mEnv, Cls::name);
      sClassRef = jclass(mEnv->NewGlobalRef(cls));
      mEnv->DeleteLocalRef(cls);
    }
    return sClassRef;
  }

  JNIEnv* Env() const { return mEnv; }

  template 
  bool IsInstanceOf() const {
    return mEnv->IsInstanceOf(Ref::mInstance,
                              typename T::Context(mEnv, nullptr).ClassRef());
  }

  bool operator==(const Ref& other) const {
    // Treat two references of the same object as being the same.
    return Ref::mInstance == other.Get() ||
           JNI_FALSE != mEnv->IsSameObject(Ref::mInstance, other.Get());
  }

  bool operator!=(const Ref& other) const { return !operator==(other); }

  bool operator==(decltype(nullptr)) const { return !Ref::mInstance; }

  bool operator!=(decltype(nullptr)) const { return !!Ref::mInstance; }

  Cls operator->() const {
    MOZ_ASSERT(Ref::mInstance, "Null jobject");
    return Cls(*this);
  }

  const Context& operator*() const { return *this; }
};

template 
jclass Context::sClassRef;

template 
class ObjectBase {
 protected:
  const jni::Context& mCtx;

  jclass ClassRef() const { return mCtx.ClassRef(); }
  JNIEnv* Env() const { return mCtx.Env(); }
  Type Instance() const { return mCtx.Get(); }

 public:
  using Ref = jni::Ref;
  using Context = jni::Context;
  using LocalRef = jni::LocalRef;
  using GlobalRef = jni::GlobalRef;
  using WeakRef = jni::WeakRef;
  using Param = const Ref&;

  static const CallingThread callingThread = CallingThread::ANY;
  static const char name[];

  explicit ObjectBase(const Context& ctx) : mCtx(ctx) {}

  Cls* operator->() { return static_cast(this); }
};

// Binding for a plain jobject.
class Object : public ObjectBase {
 public:
  explicit Object(const Context& ctx) : ObjectBase(ctx) {}
};

// Binding for a built-in object reference other than jobject.
template 
class TypedObject : public ObjectBase, T> {
 public:
  explicit TypedObject(const Context, T>& ctx)
      : ObjectBase, T>(ctx) {}
};

// Binding for a boxed primitive object.
template 
class BoxedObject : public ObjectBase, jobject> {
 public:
  explicit BoxedObject(const Context, jobject>& ctx)
      : ObjectBase, jobject>(ctx) {}
};

template <>
const char ObjectBase::name[];
template <>
const char ObjectBase, jstring>::name[];
template <>
const char ObjectBase, jclass>::name[];
template <>
const char ObjectBase, jthrowable>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jobject>::name[];
template <>
const char ObjectBase, jbooleanArray>::name[];
template <>
const char ObjectBase, jbyteArray>::name[];
template <>
const char ObjectBase, jcharArray>::name[];
template <>
const char ObjectBase, jshortArray>::name[];
template <>
const char ObjectBase, jintArray>::name[];
template <>
const char ObjectBase, jlongArray>::name[];
template <>
const char ObjectBase, jfloatArray>::name[];
template <>
const char ObjectBase, jdoubleArray>::name[];
template <>
const char ObjectBase, jobjectArray>::name[];

// Define bindings for built-in types.
using String = TypedObject;
using Class = TypedObject;
using Throwable = TypedObject;

using Boolean = BoxedObject;
using Byte = BoxedObject;
using Character = BoxedObject;
using Short = BoxedObject;
using Integer = BoxedObject;
using Long = BoxedObject;
using Float = BoxedObject;
using Double = BoxedObject;

using BooleanArray = TypedObject;
using ByteArray = TypedObject;
using CharArray = TypedObject;
using ShortArray = TypedObject;
using IntArray = TypedObject;
using LongArray = TypedObject;
using FloatArray = TypedObject;
using DoubleArray = TypedObject;
using ObjectArray = TypedObject;

namespace detail {

// See explanation in LocalRef.
template 
struct GenericObject {
  using Type = Object;
};
template <>
struct GenericObject