status-im
/
react-native
mirror of https://github.com/status-im/react-native.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Simplify memory model between managed and unmanaged memory 

Differential Revision: D4051454

fbshipit-source-id: 8f5d010be520b3d1c981a7f85e5e6d95773ea6c1
This commit is contained in:
Emil Sjolander 2016-10-24 10:35:41 -07:00 committed by Facebook Github Bot
parent 6a774f0af1
commit 58b5e28e71
5 changed files with 26 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
React/CSSLayout/CSSLayout.c
View File

@ -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;
}

1
React/CSSLayout/CSSLayout.h
View File

@ -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,

97
ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java
View File

@ -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 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<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!");
}

3
ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java
View File

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

7
ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeDEPRECATED.java
View File

@ -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");
}