Simplify memory model between managed and unmanaged memory

Summary: Instead of having different lifetimes for java and c memory we can can tie them together and make them much easier to manage. This also leads to automatically pooling native memory if pooling java memory.

Differential Revision: D4051454

fbshipit-source-id: 8f5d010be520b3d1c981a7f85e5e6d95773ea6c1

CSSLayout/CSSLayout.c

@@ -169,6 +169,15 @@ void CSSNodeFreeRecursive(const CSSNodeRef root) {
   CSSNodeFree(root);
 }
 
+void CSSNodeReset(const CSSNodeRef node) {
+  CSS_ASSERT(CSSNodeChildCount(node) == 0, "Cannot reset a node which still has children attached");
+  CSS_ASSERT(node->parent == NULL, "Cannot reset a node still attached to a parent");
+  
+  CSSNodeListFree(node->children);
+  memset(node, 0, sizeof(CSSNode));
+  CSSNodeInit(node);
+}
+
 int32_t CSSNodeGetInstanceCount(void) {
   return gNodeInstanceCount;
 }

CSSLayout/CSSLayout.h

@@ -133,6 +133,7 @@ WIN_EXPORT CSSNodeRef CSSNodeNew(void);
 WIN_EXPORT void CSSNodeInit(const CSSNodeRef node);
 WIN_EXPORT void CSSNodeFree(const CSSNodeRef node);
 WIN_EXPORT void CSSNodeFreeRecursive(const CSSNodeRef node);
+WIN_EXPORT void CSSNodeReset(const CSSNodeRef node);
 WIN_EXPORT int32_t CSSNodeGetInstanceCount(void);
 
 WIN_EXPORT void CSSNodeInsertChild(const CSSNodeRef node,

csharp/Facebook.CSSLayout/CSSNode.cs

@@ -17,7 +17,6 @@ namespace Facebook.CSSLayout
 {
     public class CSSNode : IDisposable, IEnumerable<CSSNode>
     {
-        private bool _isDisposed;
         private IntPtr _cssNode;
 
         private WeakReference _parent;
@@ -27,118 +26,38 @@ namespace Facebook.CSSLayout
 
         public CSSNode()
         {
-            Reinitialize();
+            CSSAssert.Initialize();
-        }
+            CSSLogger.Initialize();
-
+            _children = new List<CSSNode>(4);
-        private void AssertNativeInstance()
-        {
-            if (_isDisposed)
-            {
-                throw new ObjectDisposedException("CSSNode");
-            }
 
+            _cssNode = Native.CSSNodeNew();
             if (_cssNode == IntPtr.Zero)
             {
-                throw new InvalidOperationException("Null native pointer");
+                throw new InvalidOperationException("Failed to allocate native memory");
             }
+
         }
 
         ~CSSNode()
         {
-            Dispose(false);
+            Native.CSSNodeFree(_cssNode);
         }
 
-        public void Dispose()
+        public void Reset()
         {
-            Dispose(true);
+            Native.CSSNodeReset(_cssNode);
-            GC.SuppressFinalize(this);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (!_isDisposed)
-            {
-                if (disposing)
-                {
-                    FreeManaged();
-                }
-
-                FreeUnmanaged();
-                _isDisposed = true;
-            }
-        }
-
-        private void FreeManaged()
-        {
-            if (_children != null)
-            {
-                for (int i = 0; i < _children.Count; ++i)
-                {
-                    var child = _children[i];
-                    child.AssertNativeInstance();
-                    child._parent = null;
-                    Native.CSSNodeRemoveChild(_cssNode, child._cssNode);
-                }
-                _children = null;
-            }
-
-            if (_parent != null)
-            {
-                var parent = _parent.Target as CSSNode;
-                parent.AssertNativeInstance();
-                parent._children.Remove(this);
-                Native.CSSNodeRemoveChild(parent._cssNode, _cssNode);
-                _parent = null;
-            }
-
-            _measureFunction = null;
-        }
-
-        private void FreeUnmanaged()
-        {
-            if (_cssNode != IntPtr.Zero)
-            {
-                Native.CSSNodeFree(_cssNode);
-                _cssNode = IntPtr.Zero;
-            }
-        }
-
-        public void Reinitialize()
-        {
-            if (_cssNode != IntPtr.Zero)
-            {
-                throw new InvalidOperationException("Allready initialized node");
-            }
-
-            CSSAssert.Initialize();
-            CSSLogger.Initialize();
-            _cssNode = Native.CSSNodeNew();
-            _children = new List<CSSNode>(4);
-        }
-
-        public void Free()
-        {
-            AssertNativeInstance();
-            if (_parent != null || (_children != null && _children.Count > 0))
-            {
-                throw new InvalidOperationException("You should not free an attached CSSNode");
-            }
-            FreeManaged();
-            FreeUnmanaged();
         }
 
         public bool IsDirty
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeIsDirty(_cssNode);
             }
         }
 
         public virtual void MarkDirty()
         {
-            AssertNativeInstance();
             Native.CSSNodeMarkDirty(_cssNode);
         }
 
@@ -146,13 +65,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeGetIsTextnode(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeSetIsTextnode(_cssNode, value);
             }
         }
@@ -161,14 +78,12 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeGetHasNewLayout(_cssNode);
             }
         }
 
         public void MarkHasNewLayout()
         {
-            AssertNativeInstance();
             Native.CSSNodeSetHasNewLayout(_cssNode, true);
         }
 
@@ -176,7 +91,6 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return _parent != null ? _parent.Target as CSSNode : null;
             }
         }
@@ -193,12 +107,10 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetDirection(_cssNode);
             }
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetDirection(_cssNode, value);
             }
         }
@@ -207,13 +119,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetFlexDirection(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetFlexDirection(_cssNode, value);
             }
         }
@@ -222,13 +132,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetJustifyContent(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetJustifyContent(_cssNode, value);
             }
         }
@@ -237,13 +145,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetAlignItems(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetAlignItems(_cssNode, value);
             }
         }
@@ -252,13 +158,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetAlignSelf(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetAlignSelf(_cssNode, value);
             }
         }
@@ -267,13 +171,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetAlignContent(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetAlignContent(_cssNode, value);
             }
         }
@@ -282,13 +184,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetPositionType(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetPositionType(_cssNode, value);
             }
         }
@@ -297,13 +197,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetFlexWrap(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetFlexWrap(_cssNode, value);
             }
         }
@@ -312,7 +210,6 @@ namespace Facebook.CSSLayout
         {
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetFlex(_cssNode, value);
             }
         }
@@ -321,13 +218,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetFlexGrow(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetFlexGrow(_cssNode, value);
             }
         }
@@ -336,13 +231,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetFlexShrink(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetFlexShrink(_cssNode, value);
             }
         }
@@ -351,20 +244,17 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetFlexBasis(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetFlexBasis(_cssNode, value);
             }
         }
 
         public Spacing GetMargin()
         {
-            AssertNativeInstance();
 
             var margin = new Spacing();
             margin.Set(Spacing.Left, Native.CSSNodeStyleGetMargin(_cssNode, CSSEdge.Left));
@@ -379,13 +269,11 @@ namespace Facebook.CSSLayout
 
         public void SetMargin(CSSEdge edge, float value)
         {
-            AssertNativeInstance();
             Native.CSSNodeStyleSetMargin(_cssNode, edge, value);
         }
 
         public Spacing GetPadding()
         {
-            AssertNativeInstance();
 
             var padding = new Spacing();
             padding.Set(Spacing.Left, Native.CSSNodeStyleGetPadding(_cssNode, CSSEdge.Left));
@@ -400,13 +288,11 @@ namespace Facebook.CSSLayout
 
         public void SetPadding(CSSEdge edge, float padding)
         {
-            AssertNativeInstance();
             Native.CSSNodeStyleSetPadding(_cssNode, edge, padding);
         }
 
         public Spacing GetBorder()
         {
-            AssertNativeInstance();
 
             var border = new Spacing();
             border.Set(Spacing.Left, Native.CSSNodeStyleGetBorder(_cssNode, CSSEdge.Left));
@@ -421,13 +307,11 @@ namespace Facebook.CSSLayout
 
         public void SetBorder(CSSEdge edge, float border)
         {
-            AssertNativeInstance();
             Native.CSSNodeStyleSetBorder(_cssNode, edge, border);
         }
 
         public Spacing GetPosition()
         {
-            AssertNativeInstance();
 
             var position = new Spacing();
             position.Set(Spacing.Left, Native.CSSNodeStyleGetPosition(_cssNode, CSSEdge.Left));
@@ -442,7 +326,6 @@ namespace Facebook.CSSLayout
 
         public void SetPosition(CSSEdge edge, float position)
         {
-            AssertNativeInstance();
             Native.CSSNodeStyleSetPosition(_cssNode, edge, position);
         }
 
@@ -450,13 +333,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetWidth(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetWidth(_cssNode, value);
             }
         }
@@ -465,13 +346,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetHeight(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetHeight(_cssNode, value);
             }
         }
@@ -480,13 +359,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetMaxWidth(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetMaxWidth(_cssNode, value);
             }
         }
@@ -495,13 +372,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetMaxHeight(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetMaxHeight(_cssNode, value);
             }
         }
@@ -510,13 +385,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetMinWidth(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetMinWidth(_cssNode, value);
             }
         }
@@ -525,13 +398,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetMinHeight(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetMinHeight(_cssNode, value);
             }
         }
@@ -540,7 +411,6 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeLayoutGetLeft(_cssNode);
             }
         }
@@ -549,7 +419,6 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeLayoutGetTop(_cssNode);
             }
         }
@@ -558,7 +427,6 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeLayoutGetWidth(_cssNode);
             }
         }
@@ -567,7 +435,6 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeLayoutGetHeight(_cssNode);
             }
         }
@@ -576,7 +443,6 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeLayoutGetDirection(_cssNode);
             }
         }
@@ -585,13 +451,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return Native.CSSNodeStyleGetOverflow(_cssNode);
             }
 
             set
             {
-                AssertNativeInstance();
                 Native.CSSNodeStyleSetOverflow(_cssNode, value);
             }
         }
@@ -600,13 +464,11 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return _data;
             }
 
             set
             {
-                AssertNativeInstance();
                 _data = value;
             }
         }
@@ -615,7 +477,6 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return _children[index];
             }
         }
@@ -624,14 +485,12 @@ namespace Facebook.CSSLayout
         {
             get
             {
-                AssertNativeInstance();
                 return _children.Count;
             }
         }
 
         public void MarkLayoutSeen()
         {
-            AssertNativeInstance();
             Native.CSSNodeSetHasNewLayout(_cssNode, false);
         }
 
@@ -647,7 +506,6 @@ namespace Facebook.CSSLayout
 
         public void Insert(int index, CSSNode node)
         {
-            AssertNativeInstance();
             _children.Insert(index, node);
             node._parent = new WeakReference(this);
             Native.CSSNodeInsertChild(_cssNode, node._cssNode, (uint)index);
@@ -655,7 +513,6 @@ namespace Facebook.CSSLayout
 
         public void RemoveAt(int index)
         {
-            AssertNativeInstance();
             var child = _children[index];
             child._parent = null;
             _children.RemoveAt(index);
@@ -664,20 +521,17 @@ namespace Facebook.CSSLayout
 
         public int IndexOf(CSSNode node)
         {
-            AssertNativeInstance();
             return _children.IndexOf(node);
         }
 
         public void SetMeasureFunction(MeasureFunction measureFunction)
         {
-            AssertNativeInstance();
             _measureFunction = measureFunction;
             Native.CSSNodeSetMeasureFunc(_cssNode, measureFunction != null ? MeasureInternal : (CSSMeasureFunc)null);
         }
 
         public void CalculateLayout()
         {
-            AssertNativeInstance();
             Native.CSSNodeCalculateLayout(_cssNode, CSSConstants.Undefined, CSSConstants.Undefined, Native.CSSNodeStyleGetDirection(_cssNode));
         }
 
@@ -701,7 +555,6 @@ namespace Facebook.CSSLayout
 
         public string Print(CSSPrintOptions options = CSSPrintOptions.Layout|CSSPrintOptions.Style|CSSPrintOptions.Children)
         {
-            AssertNativeInstance();
             StringBuilder sb = new StringBuilder();
             CSSLogger.Logger = (message) => {sb.Append(message);};
             Native.CSSNodePrint(_cssNode, options);

csharp/Facebook.CSSLayout/Native.cs

@@ -37,6 +37,9 @@ namespace Facebook.CSSLayout
         [DllImport(DllName)]
         public static extern void CSSNodeFree(IntPtr cssNode);
 
+        [DllImport(DllName)]
+        public static extern void CSSNodeReset(IntPtr cssNode);
+
         [DllImport(DllName)]
         public static extern int CSSNodeGetInstanceCount();
 

java/com/facebook/csslayout/CSSNode.java

@@ -40,40 +40,30 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private long mNativePointer;
   private Object mData;
 
-  public CSSNode() {
-    reinit();
-  }
-
-  private void assertNativeInstance() {
-    if (mNativePointer == 0) {
-      throw new IllegalStateException("Null native pointer");
-    }
-  }
-
   private native long jni_CSSNodeNew();
-  @Override
+  public CSSNode() {
-  public void reinit() {
+    mNativePointer = jni_CSSNodeNew();
-    if (mNativePointer != 0) {
+    if (mNativePointer == 0) {
-      throw new IllegalStateException("Allready initialized node");
+      throw new IllegalStateException("Failed to allocate native memory");
     }
 
-    mNativePointer = jni_CSSNodeNew();
     mChildren = new ArrayList<>(4);
   }
 
   private native void jni_CSSNodeFree(long nativePointer);
   @Override
-  public void free() {
+  protected void finalize() throws Throwable {
-    assertNativeInstance();
+    try {
-    if (mParent != null || (mChildren != null && mChildren.size() > 0)) {
+      jni_CSSNodeFree(mNativePointer);
-      throw new IllegalStateException("You should not free an attached CSSNode");
+    } finally {
+      super.finalize();
     }
+  }
 
-    jni_CSSNodeFree(mNativePointer);
+  private native void jni_CSSNodeReset(long nativePointer);
-    mNativePointer = 0;
+  @Override
-    mChildren = null;
+  public void reset() {
-    mParent = null;
+    jni_CSSNodeReset(mNativePointer);
-    mMeasureFunction = null;
   }
 
   @Override
@@ -89,7 +79,6 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeInsertChild(long nativePointer, long childPointer, int index);
   @Override
   public void addChildAt(CSSNode child, int i) {
-    assertNativeInstance();
     if (child.mParent != null) {
       throw new IllegalStateException("Child already has a parent, it must be removed first.");
     }
@@ -102,7 +91,6 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeRemoveChild(long nativePointer, long childPointer);
   @Override
   public CSSNode removeChildAt(int i) {
-    assertNativeInstance();
 
     final CSSNode child = mChildren.remove(i);
     child.mParent = null;
@@ -124,35 +112,30 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeSetIsTextNode(long nativePointer, boolean isTextNode);
   @Override
   public void setIsTextNode(boolean isTextNode) {
-    assertNativeInstance();
     jni_CSSNodeSetIsTextNode(mNativePointer, isTextNode);
   }
 
   private native boolean jni_CSSNodeGetIsTextNode(long nativePointer);
   @Override
   public boolean isTextNode() {
-    assertNativeInstance();
     return jni_CSSNodeGetIsTextNode(mNativePointer);
   }
 
   private native void jni_CSSNodeCalculateLayout(long nativePointer);
   @Override
   public void calculateLayout(CSSLayoutContext layoutContext) {
-    assertNativeInstance();
     jni_CSSNodeCalculateLayout(mNativePointer);
   }
 
   private native boolean jni_CSSNodeHasNewLayout(long nativePointer);
   @Override
   public boolean hasNewLayout() {
-    assertNativeInstance();
     return jni_CSSNodeHasNewLayout(mNativePointer);
   }
 
   private native void jni_CSSNodeMarkDirty(long nativePointer);
   @Override
   public void dirty() {
-    assertNativeInstance();
     jni_CSSNodeMarkDirty(mNativePointer);
   }
 
@@ -165,189 +148,162 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeMarkLayoutSeen(long nativePointer);
   @Override
   public void markLayoutSeen() {
-    assertNativeInstance();
     jni_CSSNodeMarkLayoutSeen(mNativePointer);
   }
 
   private native int jni_CSSNodeStyleGetDirection(long nativePointer);
   @Override
   public CSSDirection getStyleDirection() {
-    assertNativeInstance();
     return CSSDirection.values()[jni_CSSNodeStyleGetDirection(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetDirection(long nativePointer, int direction);
   @Override
   public void setDirection(CSSDirection direction) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetDirection(mNativePointer, direction.ordinal());
   }
 
   private native int jni_CSSNodeLayoutGetDirection(long nativePointer);
   @Override
   public CSSDirection getLayoutDirection() {
-    assertNativeInstance();
     return CSSDirection.values()[jni_CSSNodeLayoutGetDirection(mNativePointer)];
   }
 
   private native int jni_CSSNodeStyleGetFlexDirection(long nativePointer);
   @Override
   public CSSFlexDirection getFlexDirection() {
-    assertNativeInstance();
     return CSSFlexDirection.values()[jni_CSSNodeStyleGetFlexDirection(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetFlexDirection(long nativePointer, int flexDirection);
   @Override
   public void setFlexDirection(CSSFlexDirection flexDirection) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexDirection(mNativePointer, flexDirection.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetJustifyContent(long nativePointer);
   @Override
   public CSSJustify getJustifyContent() {
-    assertNativeInstance();
     return CSSJustify.values()[jni_CSSNodeStyleGetJustifyContent(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetJustifyContent(long nativePointer, int justifyContent);
   @Override
   public void setJustifyContent(CSSJustify justifyContent) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetJustifyContent(mNativePointer, justifyContent.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetAlignItems(long nativePointer);
   @Override
   public CSSAlign getAlignItems() {
-    assertNativeInstance();
     return CSSAlign.values()[jni_CSSNodeStyleGetAlignItems(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetAlignItems(long nativePointer, int alignItems);
   @Override
   public void setAlignItems(CSSAlign alignItems) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetAlignItems(mNativePointer, alignItems.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetAlignSelf(long nativePointer);
   @Override
   public CSSAlign getAlignSelf() {
-    assertNativeInstance();
     return CSSAlign.values()[jni_CSSNodeStyleGetAlignSelf(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetAlignSelf(long nativePointer, int alignSelf);
   @Override
   public void setAlignSelf(CSSAlign alignSelf) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetAlignSelf(mNativePointer, alignSelf.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetAlignContent(long nativePointer);
   @Override
   public CSSAlign getAlignContent() {
-    assertNativeInstance();
     return CSSAlign.values()[jni_CSSNodeStyleGetAlignContent(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetAlignContent(long nativePointer, int alignContent);
   @Override
   public void setAlignContent(CSSAlign alignContent) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetAlignContent(mNativePointer, alignContent.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetPositionType(long nativePointer);
   @Override
   public CSSPositionType getPositionType() {
-    assertNativeInstance();
     return CSSPositionType.values()[jni_CSSNodeStyleGetPositionType(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetPositionType(long nativePointer, int positionType);
   @Override
   public void setPositionType(CSSPositionType positionType) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetPositionType(mNativePointer, positionType.ordinal());
   }
 
   private native void jni_CSSNodeStyleSetFlexWrap(long nativePointer, int wrapType);
   @Override
   public void setWrap(CSSWrap flexWrap) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexWrap(mNativePointer, flexWrap.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetOverflow(long nativePointer);
   @Override
   public CSSOverflow getOverflow() {
-    assertNativeInstance();
     return CSSOverflow.values()[jni_CSSNodeStyleGetOverflow(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetOverflow(long nativePointer, int overflow);
   @Override
   public void setOverflow(CSSOverflow overflow) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetOverflow(mNativePointer, overflow.ordinal());
   }
 
   private native void jni_CSSNodeStyleSetFlex(long nativePointer, float flex);
   @Override
   public void setFlex(float flex) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlex(mNativePointer, flex);
   }
 
   private native float jni_CSSNodeStyleGetFlexGrow(long nativePointer);
   @Override
   public float getFlexGrow() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetFlexGrow(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetFlexGrow(long nativePointer, float flexGrow);
   @Override
   public void setFlexGrow(float flexGrow) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexGrow(mNativePointer, flexGrow);
   }
 
   private native float jni_CSSNodeStyleGetFlexShrink(long nativePointer);
   @Override
   public float getFlexShrink() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetFlexShrink(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetFlexShrink(long nativePointer, float flexShrink);
   @Override
   public void setFlexShrink(float flexShrink) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexShrink(mNativePointer, flexShrink);
   }
 
   private native float jni_CSSNodeStyleGetFlexBasis(long nativePointer);
   @Override
   public float getFlexBasis() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetFlexBasis(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetFlexBasis(long nativePointer, float flexBasis);
   @Override
   public void setFlexBasis(float flexBasis) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexBasis(mNativePointer, flexBasis);
   }
 
   private native float jni_CSSNodeStyleGetMargin(long nativePointer, int edge);
   @Override
   public Spacing getMargin() {
-    assertNativeInstance();
     Spacing margin = new Spacing();
     margin.set(Spacing.LEFT, jni_CSSNodeStyleGetMargin(mNativePointer, Spacing.LEFT));
     margin.set(Spacing.TOP, jni_CSSNodeStyleGetMargin(mNativePointer, Spacing.TOP));
@@ -361,14 +317,12 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetMargin(long nativePointer, int edge, float margin);
   @Override
   public void setMargin(int spacingType, float margin) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMargin(mNativePointer, spacingType, margin);
   }
 
   private native float jni_CSSNodeStyleGetPadding(long nativePointer, int edge);
   @Override
   public Spacing getPadding() {
-    assertNativeInstance();
     Spacing padding = new Spacing();
     padding.set(Spacing.LEFT, jni_CSSNodeStyleGetPadding(mNativePointer, Spacing.LEFT));
     padding.set(Spacing.TOP, jni_CSSNodeStyleGetPadding(mNativePointer, Spacing.TOP));
@@ -382,14 +336,12 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetPadding(long nativePointer, int edge, float padding);
   @Override
   public void setPadding(int spacingType, float padding) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetPadding(mNativePointer, spacingType, padding);
   }
 
   private native float jni_CSSNodeStyleGetBorder(long nativePointer, int edge);
   @Override
   public Spacing getBorder() {
-    assertNativeInstance();
     Spacing border = new Spacing();
     border.set(Spacing.LEFT, jni_CSSNodeStyleGetBorder(mNativePointer, Spacing.LEFT));
     border.set(Spacing.TOP, jni_CSSNodeStyleGetBorder(mNativePointer, Spacing.TOP));
@@ -403,14 +355,12 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetBorder(long nativePointer, int edge, float border);
   @Override
   public void setBorder(int spacingType, float border) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetBorder(mNativePointer, spacingType, border);
   }
 
   private native float jni_CSSNodeStyleGetPosition(long nativePointer, int edge);
   @Override
   public Spacing getPosition() {
-    assertNativeInstance();
     Spacing position = new Spacing();
     position.set(Spacing.LEFT, jni_CSSNodeStyleGetPosition(mNativePointer, Spacing.LEFT));
     position.set(Spacing.TOP, jni_CSSNodeStyleGetPosition(mNativePointer, Spacing.TOP));
@@ -424,133 +374,114 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetPosition(long nativePointer, int edge, float position);
   @Override
   public void setPosition(int spacingType, float position) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetPosition(mNativePointer, spacingType, position);
   }
 
   private native float jni_CSSNodeStyleGetWidth(long nativePointer);
   @Override
   public float getStyleWidth() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetWidth(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetWidth(long nativePointer, float width);
   @Override
   public void setStyleWidth(float width) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetWidth(mNativePointer, width);
   }
 
   private native float jni_CSSNodeStyleGetHeight(long nativePointer);
   @Override
   public float getStyleHeight() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetHeight(long nativePointer, float height);
   @Override
   public void setStyleHeight(float height) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetHeight(mNativePointer, height);
   }
 
   private native float jni_CSSNodeStyleGetMinWidth(long nativePointer);
   @Override
   public float getStyleMinWidth() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMinWidth(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMinWidth(long nativePointer, float minWidth);
   @Override
   public void setStyleMinWidth(float minWidth) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMinWidth(mNativePointer, minWidth);
   }
 
   private native float jni_CSSNodeStyleGetMinHeight(long nativePointer);
   @Override
   public float getStyleMinHeight() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMinHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMinHeight(long nativePointer, float minHeight);
   @Override
   public void setStyleMinHeight(float minHeight) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMinHeight(mNativePointer, minHeight);
   }
 
   private native float jni_CSSNodeStyleGetMaxWidth(long nativePointer);
   @Override
   public float getStyleMaxWidth() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMaxWidth(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMaxWidth(long nativePointer, float maxWidth);
   @Override
   public void setStyleMaxWidth(float maxWidth) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMaxWidth(mNativePointer, maxWidth);
   }
 
   private native float jni_CSSNodeStyleGetMaxHeight(long nativePointer);
   @Override
   public float getStyleMaxHeight() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMaxHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMaxHeight(long nativePointer, float maxheight);
   @Override
   public void setStyleMaxHeight(float maxheight) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMaxHeight(mNativePointer, maxheight);
   }
 
   private native float jni_CSSNodeLayoutGetLeft(long nativePointer);
   @Override
   public float getLayoutX() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetLeft(mNativePointer);
   }
 
   private native float jni_CSSNodeLayoutGetTop(long nativePointer);
   @Override
   public float getLayoutY() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetTop(mNativePointer);
   }
 
   private native float jni_CSSNodeLayoutGetWidth(long nativePointer);
   @Override
   public float getLayoutWidth() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetWidth(mNativePointer);
   }
 
   private native float jni_CSSNodeLayoutGetHeight(long nativePointer);
   @Override
   public float getLayoutHeight() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeSetHasMeasureFunc(long nativePointer, boolean hasMeasureFunc);
   @Override
   public void setMeasureFunction(MeasureFunction measureFunction) {
-    assertNativeInstance();
     mMeasureFunction = measureFunction;
     jni_CSSNodeSetHasMeasureFunc(mNativePointer, measureFunction != null);
   }
 
   @DoNotStrip
   public long measure(float width, int widthMode, float height, int heightMode) {
-    assertNativeInstance();
     if (!isMeasureDefined()) {
       throw new RuntimeException("Measure function isn't defined!");
     }

java/com/facebook/csslayout/CSSNodeAPI.java

@@ -88,6 +88,5 @@ public interface CSSNodeAPI<CSSNodeType extends CSSNodeAPI> {
   void setOverflow(CSSOverflow overflow);
   void setData(Object data);
   Object getData();
-  void reinit();
+  void reset();
-  void free();
 }

java/com/facebook/csslayout/CSSNodeDEPRECATED.java

@@ -61,11 +61,6 @@ public class CSSNodeDEPRECATED implements CSSNodeAPI<CSSNodeDEPRECATED> {
   private boolean mIsTextNode = false;
   private Object mData;
 
-  @Override
-  public void reinit() {
-    free();
-  }
-
   @Override
   public int getChildCount() {
     return mChildren == null ? 0 : mChildren.size();
@@ -626,7 +621,7 @@ public class CSSNodeDEPRECATED implements CSSNodeAPI<CSSNodeDEPRECATED> {
    * recycling {@link CSSNodeDEPRECATED} instances.
    */
   @Override
-  public void free() {
+  public void reset() {
     if (mParent != null || (mChildren != null && mChildren.size() > 0)) {
       throw new IllegalStateException("You should not free an attached CSSNodeDEPRECATED");
     }

java/jni/CSSJNI.cpp

@@ -59,6 +59,14 @@ void jni_CSSNodeFree(alias_ref<jobject> thiz, jlong nativePointer) {
   CSSNodeFree(_jlong2CSSNodeRef(nativePointer));
 }
 
+void jni_CSSNodeReset(alias_ref<jobject> thiz, jlong nativePointer) {
+  const CSSNodeRef node = _jlong2CSSNodeRef(nativePointer);
+  void *context = CSSNodeGetContext(node);
+  CSSNodeReset(node);
+  CSSNodeSetContext(node, context);
+  CSSNodeSetPrintFunc(node, _jniPrint);
+}
+
 void jni_CSSNodeInsertChild(alias_ref<jobject>,
                             jlong nativePointer,
                             jlong childPointer,
@@ -179,6 +187,7 @@ jint JNI_OnLoad(JavaVM *vm, void *) {
                     {
                         CSSMakeNativeMethod(jni_CSSNodeNew),
                         CSSMakeNativeMethod(jni_CSSNodeFree),
+                        CSSMakeNativeMethod(jni_CSSNodeReset),
                         CSSMakeNativeMethod(jni_CSSNodeInsertChild),
                         CSSMakeNativeMethod(jni_CSSNodeRemoveChild),
                         CSSMakeNativeMethod(jni_CSSNodeSetIsTextNode),

java/tests/com/facebook/csslayout/CSSNodeTest.java

@@ -22,23 +22,6 @@ public class CSSNodeTest {
     assertEquals(refCount + 1, CSSNode.jni_CSSNodeGetInstanceCount());
   }
 
-  @Test
-  public void testFree() {
-    final int refCount = CSSNode.jni_CSSNodeGetInstanceCount();
-    final CSSNode node = new CSSNode();
-    node.free();
-    assertEquals(refCount, CSSNode.jni_CSSNodeGetInstanceCount());
-  }
-
-  @Test
-  public void testReinit() {
-    final int refCount = CSSNode.jni_CSSNodeGetInstanceCount();
-    final CSSNode node = new CSSNode();
-    node.free();
-    node.reinit();
-    assertEquals(refCount + 1, CSSNode.jni_CSSNodeGetInstanceCount());
-  }
-
   @Test
   public void testMeasure() {
     final CSSNode node = new CSSNode();