| Accessors.h |
|
7342 |
| Conversions.cpp |
|
3310 |
| Conversions.h |
|
686 |
| GeckoBundleUtils.cpp |
|
10090 |
| GeckoBundleUtils.h |
|
2128 |
| GeckoResultUtils.h |
|
2034 |
| moz.build |
|
805 |
| Natives.h |
C++ classes implementing instance (non-static) native methods can choose
from one of two ownership models, when associating a C++ object with a Java
instance.
* If the C++ class inherits from mozilla::SupportsWeakPtr, weak pointers
will be used. The Java instance will store and own the pointer to a
WeakPtr object. The C++ class itself is otherwise not owned or directly
referenced. Note that mozilla::SupportsWeakPtr only supports being used on
a single thread. To attach a Java instance to a C++ instance, pass in a
mozilla::SupportsWeakPtr pointer to the C++ class (i.e. MyClass*).
class MyClass : public SupportsWeakPtr
, public MyJavaClass::Natives<MyClass>
{
// ...
public:
using MyJavaClass::Natives<MyClass>::DisposeNative;
void AttachTo(const MyJavaClass::LocalRef& instance)
{
MyJavaClass::Natives<MyClass>::AttachNative(
instance, static_cast<SupportsWeakPtr*>(this));
// "instance" does NOT own "this", so the C++ object
// lifetime is separate from the Java object lifetime.
}
};
* If the C++ class contains public members AddRef() and Release(), the Java
instance will store and own the pointer to a RefPtr object, which holds a
strong reference on the C++ instance. Normal ref-counting considerations
apply in this case; for example, disposing may cause the C++ instance to
be deleted and the destructor to be run on the current thread, which may
not be desirable. To attach a Java instance to a C++ instance, pass in a
pointer to the C++ class (i.e. MyClass*).
class MyClass : public RefCounted<MyClass>
, public MyJavaClass::Natives<MyClass>
{
// ...
public:
using MyJavaClass::Natives<MyClass>::DisposeNative;
void AttachTo(const MyJavaClass::LocalRef& instance)
{
MyJavaClass::Natives<MyClass>::AttachNative(instance, this);
// "instance" owns "this" through the RefPtr, so the C++ object
// may be destroyed as soon as instance.disposeNative() is called.
}
};
* In other cases, the Java instance will store and own a pointer to the C++
object itself. This pointer must not be stored or deleted elsewhere. To
attach a Java instance to a C++ instance, pass in a reference to a
UniquePtr of the C++ class (i.e. UniquePtr<MyClass>).
class MyClass : public MyJavaClass::Natives<MyClass>
{
// ...
public:
using MyJavaClass::Natives<MyClass>::DisposeNative;
static void AttachTo(const MyJavaClass::LocalRef& instance)
{
MyJavaClass::Natives<MyClass>::AttachNative(
instance, mozilla::MakeUnique<MyClass>());
// "instance" owns the newly created C++ object, so the C++
// object is destroyed as soon as instance.disposeNative() is
// called.
}
};
|
53656 |
| NativesInlines.h |
When a NativeWeakPtr is detached from its owning Java object, the calling
thread invokes the implementation's OnWeakNonIntrusiveDetach to perform
cleanup. We complete the remainder of the cleanup sequence on the Gecko
main thread by expecting OnWeakNonIntrusiveDetach implementations to invoke
this Runnable before exiting. It will move itself to the main thread if it
is not already there.
|
3961 |
| Refs.h |
|
36018 |
| TypeAdapter.h |
|
3602 |
| Types.h |
|
4669 |
| Utils.cpp |
nothing |
11984 |
| Utils.h |
|
4468 |