From 69c374e74ef7c55db32ddefd3aa3058a1de750e7 Mon Sep 17 00:00:00 2001 From: Emil Sjolander Date: Mon, 24 Oct 2016 10:35:41 -0700 Subject: [PATCH] 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 | 9 + CSSLayout/CSSLayout.h | 1 + csharp/Facebook.CSSLayout/CSSNode.cs | 165 +----------------- csharp/Facebook.CSSLayout/Native.cs | 3 + java/com/facebook/csslayout/CSSNode.java | 97 ++-------- java/com/facebook/csslayout/CSSNodeAPI.java | 3 +- .../facebook/csslayout/CSSNodeDEPRECATED.java | 7 +- java/jni/CSSJNI.cpp | 9 + .../com/facebook/csslayout/CSSNodeTest.java | 17 -- 9 files changed, 47 insertions(+), 264 deletions(-) diff --git a/CSSLayout/CSSLayout.c b/CSSLayout/CSSLayout.c index 69ed034a..c90fc3ab 100644 --- a/CSSLayout/CSSLayout.c +++ b/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; } diff --git a/CSSLayout/CSSLayout.h b/CSSLayout/CSSLayout.h index 50826d5b..0dd3f1ca 100644 --- a/CSSLayout/CSSLayout.h +++ b/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, diff --git a/csharp/Facebook.CSSLayout/CSSNode.cs b/csharp/Facebook.CSSLayout/CSSNode.cs index 5f8999b7..bd825ae8 100644 --- a/csharp/Facebook.CSSLayout/CSSNode.cs +++ b/csharp/Facebook.CSSLayout/CSSNode.cs @@ -17,7 +17,6 @@ namespace Facebook.CSSLayout { public class CSSNode : IDisposable, IEnumerable { - private bool _isDisposed; private IntPtr _cssNode; private WeakReference _parent; @@ -27,118 +26,38 @@ namespace Facebook.CSSLayout public CSSNode() { - Reinitialize(); - } - - private void AssertNativeInstance() - { - if (_isDisposed) - { - throw new ObjectDisposedException("CSSNode"); - } + CSSAssert.Initialize(); + CSSLogger.Initialize(); + _children = new List(4); + _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); - 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(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(); + Native.CSSNodeReset(_cssNode); } 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); diff --git a/csharp/Facebook.CSSLayout/Native.cs b/csharp/Facebook.CSSLayout/Native.cs index 5d35b839..163f0049 100644 --- a/csharp/Facebook.CSSLayout/Native.cs +++ b/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(); diff --git a/java/com/facebook/csslayout/CSSNode.java b/java/com/facebook/csslayout/CSSNode.java index ab3f617b..eb263dfb 100644 --- a/java/com/facebook/csslayout/CSSNode.java +++ b/java/com/facebook/csslayout/CSSNode.java @@ -40,40 +40,30 @@ public class CSSNode implements CSSNodeAPI { 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 void reinit() { - if (mNativePointer != 0) { - throw new IllegalStateException("Allready initialized node"); + public CSSNode() { + mNativePointer = jni_CSSNodeNew(); + if (mNativePointer == 0) { + 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() { - assertNativeInstance(); - if (mParent != null || (mChildren != null && mChildren.size() > 0)) { - throw new IllegalStateException("You should not free an attached CSSNode"); + protected void finalize() throws Throwable { + try { + jni_CSSNodeFree(mNativePointer); + } finally { + super.finalize(); } + } - jni_CSSNodeFree(mNativePointer); - mNativePointer = 0; - mChildren = null; - mParent = null; - mMeasureFunction = null; + private native void jni_CSSNodeReset(long nativePointer); + @Override + public void reset() { + jni_CSSNodeReset(mNativePointer); } @Override @@ -89,7 +79,6 @@ public class CSSNode implements CSSNodeAPI { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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!"); } diff --git a/java/com/facebook/csslayout/CSSNodeAPI.java b/java/com/facebook/csslayout/CSSNodeAPI.java index cbe60ff6..3af4ddb5 100644 --- a/java/com/facebook/csslayout/CSSNodeAPI.java +++ b/java/com/facebook/csslayout/CSSNodeAPI.java @@ -88,6 +88,5 @@ public interface CSSNodeAPI { void setOverflow(CSSOverflow overflow); void setData(Object data); Object getData(); - void reinit(); - void free(); + void reset(); } diff --git a/java/com/facebook/csslayout/CSSNodeDEPRECATED.java b/java/com/facebook/csslayout/CSSNodeDEPRECATED.java index ac5903fe..7d357cc0 100644 --- a/java/com/facebook/csslayout/CSSNodeDEPRECATED.java +++ b/java/com/facebook/csslayout/CSSNodeDEPRECATED.java @@ -61,11 +61,6 @@ public class CSSNodeDEPRECATED implements CSSNodeAPI { 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 { * 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"); } diff --git a/java/jni/CSSJNI.cpp b/java/jni/CSSJNI.cpp index 91cdc00b..b35f19e6 100644 --- a/java/jni/CSSJNI.cpp +++ b/java/jni/CSSJNI.cpp @@ -59,6 +59,14 @@ void jni_CSSNodeFree(alias_ref thiz, jlong nativePointer) { CSSNodeFree(_jlong2CSSNodeRef(nativePointer)); } +void jni_CSSNodeReset(alias_ref 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, 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), diff --git a/java/tests/com/facebook/csslayout/CSSNodeTest.java b/java/tests/com/facebook/csslayout/CSSNodeTest.java index a2d223df..417567a7 100644 --- a/java/tests/com/facebook/csslayout/CSSNodeTest.java +++ b/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();