Name Description Size
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