ObjectManager.h

#ifndef OBJECTMANAGER_H_
#define OBJECTMANAGER_H_

#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>

#include "ArgsWrapper.h"
#include "DirectBuffer.h"
#include "JEnv.h"
#include "JniLocalRef.h"
#include "LRUCache.h"
#include "v8.h"

namespace tns {
class ObjectManager {
 public:
  ObjectManager(jobject javaRuntimeObject);

  /*
   * Frees the JS side of every still-linked object. Must run on the runtime's
   * own thread while the isolate is alive -- it resets v8::Persistents and
   * clears internal fields. V8 does not run weak callbacks at isolate
   * disposal, so without this every linked wrapper's handle, JSInstanceInfo
   * and callback state is abandoned.
   */
  void ReleaseAllRegistered();

  /*
   * JNI-only teardown; runs from ~Runtime, after the isolate is disposed and
   * while the thread is still attached. Must not touch any v8 handle.
   */
  ~ObjectManager();

  void Init(v8::Isolate* isolate);

  JniLocalRef GetJavaObjectByJsObject(const v8::Local<v8::Object>& object);

  void UpdateCache(int objectID, jobject obj);

  jclass GetJavaClass(const v8::Local<v8::Object>& instance);

  void SetJavaClass(const v8::Local<v8::Object>& instance, jclass clazz);
  int GetOrCreateObjectId(jobject object);

  v8::Local<v8::Object> GetJsObjectByJavaObject(int javaObjectID);

  v8::Local<v8::Object> CreateJSWrapper(jint javaObjectID,
                                        const std::string& typeName);

  v8::Local<v8::Object> CreateJSWrapper(jint javaObjectID,
                                        const std::string& typeName,
                                        jobject instance);

  void Link(const v8::Local<v8::Object>& object, uint32_t javaObjectID,
            jclass clazz);

  void ReleaseNativeCounterpart(v8::Local<v8::Object>& object);

  bool CloneLink(const v8::Local<v8::Object>& src,
                 const v8::Local<v8::Object>& dest);

  bool IsJsRuntimeObject(const v8::Local<v8::Object>& object);

  static std::string GetClassName(jobject javaObject);

  static std::string GetClassName(jclass clazz);

  int GenerateNewObjectID();

  void SetInstanceIsolate(v8::Isolate* isolate);

  v8::Local<v8::Object> GetEmptyObject(v8::Isolate* isolate);

  enum class MetadataNodeKeys { JsInfo, CallSuper, END };

  /**
   * Memory management modes. Keep the members in sync with the
   * java/com/tns/MarkingMode.
   */
  enum JavaScriptMarkingMode {
    /**
     * For JavaScript instances with implementation objects that were marked for
     * collection, MarkReachableObjects will scan the whole graph of reachable
     * objects and keep strong reference to the Java instances of implementation
     * objects.
     */
    Full,
    /**
     * Fully suppress the MarkReachableObjects.
     */
    None
  };

  JavaScriptMarkingMode GetMarkingMode();

 private:
  static void InitializeJNI();
  struct JSInstanceInfo {
   public:
    JSInstanceInfo(bool isJavaObjectWeak, uint32_t javaObjectID, jclass claz)
        : IsJavaObjectWeak(isJavaObjectWeak),
          JavaObjectID(javaObjectID),
          ObjectClazz(claz) {}

    bool IsJavaObjectWeak;
    uint32_t JavaObjectID;
    jclass ObjectClazz;
  };

  struct ObjectWeakCallbackState {
    ObjectWeakCallbackState(ObjectManager* _thisPtr, JSInstanceInfo* _jsInfo,
                            v8::Persistent<v8::Object>* _target)
        : thisPtr(_thisPtr),
          jsInfo(_jsInfo),
          target(_target),
          javaObjectID(_jsInfo->JavaObjectID) {}

    ObjectManager* thisPtr;
    JSInstanceInfo* jsInfo;
    v8::Persistent<v8::Object>* target;
    // Duplicated from jsInfo: the finalizer has to unregister itself even when
    // the JsInfo field was already cleared and jsInfo freed.
    uint32_t javaObjectID;
  };

  struct GarbageCollectionInfo {
    GarbageCollectionInfo(int _numberOfGC) : numberOfGC(_numberOfGC) {}
    std::vector<v8::Persistent<v8::Object>*> markedForGC;
    int numberOfGC;
  };

  class PersistentObjectIdSet {
   public:
    PersistentObjectIdSet() { /* TODO: use functors */ }

    void clear() {
      m_POs.clear();
      m_IDs.clear();
    }

    void insert(v8::Persistent<v8::Object>* po, int javaObjectId) {
      m_POs.insert(po);
      m_IDs.insert(javaObjectId);
    }

    bool contains(v8::Persistent<v8::Object>* po) {
      return m_POs.find(po) != m_POs.end();
    }

    std::set<v8::Persistent<v8::Object>*> m_POs;
    std::set<int> m_IDs;
  };

  struct PersistentObjectIdPair {
    PersistentObjectIdPair(v8::Persistent<v8::Object>* _po, int _javaObjectId)
        : po(_po), javaObjectId(_javaObjectId) {}
    v8::Persistent<v8::Object>* po;
    int javaObjectId;
  };

  JSInstanceInfo* GetJSInstanceInfo(const v8::Local<v8::Object>& object);

  JSInstanceInfo* GetJSInstanceInfoFromRuntimeObject(
      const v8::Local<v8::Object>& object);

  void ReleaseJSInstance(v8::Persistent<v8::Object>* po,
                         JSInstanceInfo* jsInstanceInfo);

  void ReleaseRegularObjects();

  void MakeRegularObjectsWeak(const std::set<int>& instances,
                              DirectBuffer& inputBuff);

  void MakeImplObjectsWeak(
      const std::unordered_map<int, v8::Persistent<v8::Object>*>& instances,
      DirectBuffer& inputBuff);

  void CheckWeakObjectsAreAlive(
      const std::vector<PersistentObjectIdPair>& instances,
      DirectBuffer& inputBuff, DirectBuffer& outputBuff);

  v8::Local<v8::Object> CreateJSWrapperHelper(jint javaObjectID,
                                              const std::string& typeName,
                                              jclass clazz);

  static void JSObjectWeakCallbackStatic(
      const v8::WeakCallbackInfo<ObjectWeakCallbackState>& data);

  static void JSObjectFinalizerStatic(
      const v8::WeakCallbackInfo<ObjectWeakCallbackState>& data);

  void JSObjectWeakCallback(v8::Isolate* isolate,
                            ObjectWeakCallbackState* callbackState);

  void JSObjectFinalizer(v8::Isolate* isolate,
                         ObjectWeakCallbackState* callbackState);

  bool HasImplObject(v8::Isolate* isolate, const v8::Local<v8::Object>& obj);

  jweak GetJavaObjectByID(uint32_t javaObjectID);

  jobject GetJavaObjectByIDImpl(uint32_t javaObjectID);

  static jweak NewWeakGlobalRefCallback(const int& javaObjectID, void* state);

  static void DeleteWeakGlobalRefCallback(const jweak& object, void* state);

  static bool ValidateWeakGlobalRefCallback(const int& javaObjectID,
                                            const jweak& object, void* state);

  static void JSWrapperConstructorCallback(
      const v8::FunctionCallbackInfo<v8::Value>& info);

  jobject m_javaRuntimeObject;

  int m_numberOfGC;

  v8::Isolate* m_isolate;

  std::stack<GarbageCollectionInfo> m_markedForGC;

  std::unordered_map<int, ObjectWeakCallbackState*> m_idToObject;

  PersistentObjectIdSet m_released;

  std::set<unsigned long> m_visited;

  LRUCache<int, jweak> m_cache;

  std::set<v8::Persistent<v8::Object>*> m_visitedPOs;
  std::vector<PersistentObjectIdPair> m_implObjWeak;
  std::unordered_map<int, v8::Persistent<v8::Object>*> m_implObjStrong;

  volatile int m_currentObjectId;

  DirectBuffer m_buff;

  DirectBuffer m_outBuff;

  bool m_useGlobalRefs;

  JavaScriptMarkingMode m_markingMode;

  static jclass JAVA_LANG_CLASS;

  static jmethodID GET_NAME_METHOD_ID;

  static jmethodID GET_JAVAOBJECT_BY_ID_METHOD_ID;

  static jmethodID GET_OR_CREATE_JAVA_OBJECT_ID_METHOD_ID;

  static jmethodID MAKE_INSTANCE_WEAK_BATCH_METHOD_ID;

  static jmethodID MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID;

  static jmethodID RELEASE_NATIVE_INSTANCE_METHOD_ID;

  static jmethodID CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID;

  v8::Persistent<v8::Function>* m_poJsWrapperFunc = nullptr;
};
}  // namespace tns

#endif /* OBJECTMANAGER_H_ */