jdk-sandbox: comparison jdk/src/java.desktop/macosx/native/libawt

equal deleted inserted replaced

-:2752c031a620
+:de878aeb7ed2
 /*
-* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 // AccessibleRole responds (see AccessibleRole.java).
 // This cache is queried before attempting to access a given attribute for a particular role.
 static NSMutableDictionary *sAttributeNamesForRoleCache = nil;
 static NSObject *sAttributeNamesLOCK = nil;
 @interface TabGroupAccessibility : JavaComponentAccessibility {
 NSInteger _numTabs;
 }
 - (id)currentTabWithEnv:(JNIEnv *)env withAxContext:(jobject)axContext;
 {
 fParent = [parent retain];
 fView = [view retain];
 fJavaRole = [javaRole retain];
-fAccessible = JNFNewGlobalRef(env, accessible);
+fAccessible = (*env)->NewWeakGlobalRef(env, accessible);
-fComponent = JNFNewGlobalRef(env, [(AWTView *)fView awtComponent:env]);
+jobject jcomponent = [(AWTView *)fView awtComponent:env];
+fComponent = (*env)->NewWeakGlobalRef(env, jcomponent);
+(*env)->DeleteLocalRef(env, jcomponent);
 fIndex = index;
 fActions = nil;
 fActionsLOCK = [[NSObject alloc] init];
 {
 [self unregisterFromCocoaAXSystem];
 JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
-JNFDeleteGlobalRef(env, fAccessible);
+(*env)->DeleteWeakGlobalRef(env, fAccessible);
 fAccessible = NULL;
-JNFDeleteGlobalRef(env, fComponent);
+(*env)->DeleteWeakGlobalRef(env, fComponent);
 fComponent = NULL;
 [fParent release];
 fParent = nil;
 return NULL;
 }
 + (NSArray *)childrenOfParent:(JavaComponentAccessibility *)parent withEnv:(JNIEnv *)env withChildrenCode:(NSInteger)whichChildren allowIgnored:(BOOL)allowIgnored
 {
-jobjectArray jchildrenAndRoles = JNFCallStaticObjectMethod(env, jm_getChildrenAndRoles, parent->fAccessible, parent->fComponent, whichChildren, allowIgnored); // AWT_THREADING Safe (AWTRunLoop)
+jobjectArray jchildrenAndRoles = (jobjectArray)JNFCallStaticObjectMethod(env, jm_getChildrenAndRoles, parent->fAccessible, parent->fComponent, whichChildren, allowIgnored); // AWT_THREADING Safe (AWTRunLoop)
 if (jchildrenAndRoles == NULL) return nil;
 jsize arrayLen = (*env)->GetArrayLength(env, jchildrenAndRoles);
 NSMutableArray *children = [NSMutableArray arrayWithCapacity:arrayLen/2]; //childrenAndRoles array contains two elements (child, role) for each child
 jobject /* Accessible */ jchild = (*env)->GetObjectArrayElement(env, jchildrenAndRoles, i);
 jobject /* String */ jchildJavaRole = (*env)->GetObjectArrayElement(env, jchildrenAndRoles, i+1);
 NSString *childJavaRole = nil;
 if (jchildJavaRole != NULL) {
-childJavaRole = JNFJavaToNSString(env, JNFGetObjectField(env, jchildJavaRole, sjf_key));
+jobject jkey = JNFGetObjectField(env, jchildJavaRole, sjf_key);
+childJavaRole = JNFJavaToNSString(env, jkey);
+(*env)->DeleteLocalRef(env, jkey);
 }
 JavaComponentAccessibility *child = [self createWithParent:parent accessible:jchild role:childJavaRole index:childIndex withEnv:env withView:parent->fView];
+(*env)->DeleteLocalRef(env, jchild);
+(*env)->DeleteLocalRef(env, jchildJavaRole);
 [children addObject:child];
 childIndex++;
 }
+(*env)->DeleteLocalRef(env, jchildrenAndRoles);
 return children;
 }
 + (JavaComponentAccessibility *)createWithAccessible:(jobject)jaccessible withEnv:(JNIEnv *)env withView:(NSView *)view
 {
 jobject jcomponent = [(AWTView *)view awtComponent:env];
 jint index = JNFCallStaticIntMethod(env, sjm_getAccessibleIndexInParent, jaccessible, jcomponent);
 NSString *javaRole = getJavaRole(env, jaccessible, jcomponent);
+(*env)->DeleteLocalRef(env, jcomponent);
 return [self createWithAccessible:jaccessible role:javaRole index:index withEnv:env withView:view];
 }
 + (JavaComponentAccessibility *) createWithAccessible:(jobject)jaccessible role:(NSString *)javaRole index:(jint)index withEnv:(JNIEnv *)env withView:(NSView *)view
 {
 {
 // try to fetch the jCAX from Java, and return autoreleased
 jobject jCAX = [JavaComponentAccessibility getCAccessible:jaccessible withEnv:env];
 if (jCAX == NULL) return nil;
 JavaComponentAccessibility *value = (JavaComponentAccessibility *) jlong_to_ptr(JNFGetLongField(env, jCAX, jf_ptr));
-if (value != nil) return [[value retain] autorelease];
+if (value != nil) {
+(*env)->DeleteLocalRef(env, jCAX);
+return [[value retain] autorelease];
+}
 // otherwise, create a new instance
 JavaComponentAccessibility *newChild = nil;
 if ([javaRole isEqualToString:@"pagetablist"]) {
 newChild = [TabGroupAccessibility alloc];
 [newChild initWithParent:parent withEnv:env withAccessible:jCAX withIndex:index withView:view withJavaRole:javaRole]; // must init new instance
 // must hard retain pointer poked into Java object
 [newChild retain];
 JNFSetLongField(env, jCAX, jf_ptr, ptr_to_jlong(newChild));
+(*env)->DeleteLocalRef(env, jCAX);
 // return autoreleased instance
 return [newChild autorelease];
 }
 [attributeNames addObject:NSAccessibilitySubroleAttribute];
 }
 // Get all the other accessibility attributes states we need in one swell foop.
 // javaRole isn't pulled in because we need protected access to AccessibleRole.key
-jbooleanArray attributeStates = JNFCallStaticObjectMethod(env, jm_getInitialAttributeStates, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
+jbooleanArray attributeStates = (jbooleanArray)JNFCallStaticObjectMethod(env, jm_getInitialAttributeStates, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
 if (attributeStates == NULL) return nil;
 jboolean *attributeStatesArray = (*env)->GetBooleanArrayElements(env, attributeStates, 0);
 if (attributeStatesArray == NULL) {
 // Note: Java will not be on the stack here so a java exception can't happen and no need to call ExceptionCheck.
 NSLog(@"%s failed calling GetBooleanArrayElements", __FUNCTION__);
 //  the first one seems to be the most basic, so this will be used.
 // cmcnote: NOT TRUE - Sometimes there are multiple actions, eg sliders have AXDecrement AND AXIncrement (radr://3893192)
 JavaAxAction *action = [[JavaAxAction alloc] initWithEnv:env withAccessibleAction:axAction withIndex:0 withComponent:fComponent];
 [fActions setObject:action forKey:[self isMenu] ? NSAccessibilityPickAction : NSAccessibilityPressAction];
 [action release];
+(*env)->DeleteLocalRef(env, axAction);
 }
 }
 - (jobject)axContextWithEnv:(JNIEnv *)env
 {
 return getAxContext(env, fAccessible, fComponent);
 }
 - (id)parent
 {
+static JNF_CLASS_CACHE(sjc_Window, "java/awt/Window");
 static JNF_STATIC_MEMBER_CACHE(sjm_getAccessibleParent, sjc_CAccessibility, "getAccessibleParent", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljavax/accessibility/Accessible;");
+static JNF_STATIC_MEMBER_CACHE(sjm_getSwingAccessible, sjc_CAccessible, "getSwingAccessible", "(Ljavax/accessibility/Accessible;)Ljavax/accessibility/Accessible;");
 if(fParent == nil) {
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject jparent = JNFCallStaticObjectMethod(env, sjm_getAccessibleParent, fAccessible, fComponent);
 if (jparent == NULL) {
 fParent = fView;
 } else {
-fParent = [JavaComponentAccessibility createWithAccessible:jparent withEnv:env withView:fView];
+AWTView *view = fView;
+jobject jax = JNFCallStaticObjectMethod(env, sjm_getSwingAccessible, fAccessible);
+if (JNFIsInstanceOf(env, jax, &sjc_Window)) {
+// In this case jparent is an owner toplevel and we should retrieve its own view
+view = [AWTView awtView:env ofAccessible:jparent];
+}
+if (view != nil) {
+fParent = [JavaComponentAccessibility createWithAccessible:jparent withEnv:env withView:view];
+}
 if (fParent == nil) {
 fParent = fView;
 }
+(*env)->DeleteLocalRef(env, jparent);
+(*env)->DeleteLocalRef(env, jax );
 }
 [fParent retain];
 }
 return fParent;
 }
 {
 if (fIndex == -1) {
 return NO;
 }
-return isShowing(env, [self axContextWithEnv:env], fComponent);
+jobject axContext = [self axContextWithEnv:env];
+BOOL showing = isShowing(env, axContext, fComponent);
+(*env)->DeleteLocalRef(env, axContext);
+return showing;
 }
 // the array of names for each role is cached in the sAttributeNamesForRoleCache
 - (NSArray *)accessibilityAttributeNames
 {
 - (NSString *)accessibilityHelpAttribute
 {
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject val = JNFCallStaticObjectMethod(env, sjm_getAccessibleDescription, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
-return JNFJavaToNSString(env, val);
+if (val == NULL) {
+return @"unknown";
+}
+NSString* str = JNFJavaToNSString(env, val);
+(*env)->DeleteLocalRef(env, val);
+return str;
 }
 - (BOOL)accessibilityIsHelpAttributeSettable
 {
 return NO;
 static JNF_STATIC_MEMBER_CACHE(jm_getMaximumAccessibleValue, sjc_CAccessibility, "getMaximumAccessibleValue", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/Number;");
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject axValue = JNFCallStaticObjectMethod(env, jm_getMaximumAccessibleValue, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
-return JNFJavaToNSNumber(env, axValue);
+if (axValue == NULL) {
+return [NSNumber numberWithInt:0];
+}
+NSNumber* num = JNFJavaToNSNumber(env, axValue);
+(*env)->DeleteLocalRef(env, axValue);
+return num;
 }
 - (BOOL)accessibilityIsMaxValueAttributeSettable
 {
 return NO;
 static JNF_STATIC_MEMBER_CACHE(jm_getMinimumAccessibleValue, sjc_CAccessibility, "getMinimumAccessibleValue", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/Number;");
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject axValue = JNFCallStaticObjectMethod(env, jm_getMinimumAccessibleValue, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
-return JNFJavaToNSNumber(env, axValue);
+if (axValue == NULL) {
+return [NSNumber numberWithInt:0];
+}
+NSNumber* num = JNFJavaToNSNumber(env, axValue);
+(*env)->DeleteLocalRef(env, axValue);
+return num;
 }
 - (BOOL)accessibilityIsMinValueAttributeSettable
 {
 return NO;
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject axContext = [self axContextWithEnv:env];
 // cmcnote - should batch these two calls into one that returns an array of two bools, one for vertical and one for horiz
 if (isVertical(env, axContext, fComponent)) {
+(*env)->DeleteLocalRef(env, axContext);
 return NSAccessibilityVerticalOrientationValue;
 }
 if (isHorizontal(env, axContext, fComponent)) {
+(*env)->DeleteLocalRef(env, axContext);
 return NSAccessibilityHorizontalOrientationValue;
 }
+(*env)->DeleteLocalRef(env, axContext);
 return nil;
 }
 - (BOOL)accessibilityIsOrientationAttributeSettable
 {
 // bottom left based screen coords
 // Get the java screen coords, and make a NSPoint of the bottom left of the AxComponent.
 NSSize size = getAxComponentSize(env, axComponent, fComponent);
 NSPoint point = getAxComponentLocationOnScreen(env, axComponent, fComponent);
+(*env)->DeleteLocalRef(env, axComponent);
 point.y += size.height;
 // Now make it into Cocoa screen coords.
 point.y = [[[[self view] window] screen] frame].size.height - point.y;
 static JNF_STATIC_MEMBER_CACHE(jm_getAccessibleRoleDisplayString, sjc_CAccessibility, "getAccessibleRoleDisplayString", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/String;");
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject axRole = JNFCallStaticObjectMethod(env, jm_getAccessibleRoleDisplayString, fAccessible, fComponent);
-if(axRole != NULL) {
+if (axRole != NULL) {
 value = JNFJavaToNSString(env, axRole);
+(*env)->DeleteLocalRef(env, axRole);
 } else {
 value = @"unknown";
 }
 }
 // Element size (NSValue)
 - (NSValue *)accessibilitySizeAttribute {
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject axComponent = JNFCallStaticObjectMethod(env, sjm_getAccessibleComponent, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
-return [NSValue valueWithSize:getAxComponentSize(env, axComponent, fComponent)];
+NSValue* size = [NSValue valueWithSize:getAxComponentSize(env, axComponent, fComponent)];
+(*env)->DeleteLocalRef(env, axComponent);
+return size;
 }
 - (BOOL)accessibilityIsSizeAttributeSettable
 {
 // SIZE is settable in windows if [self styleMask] & NSResizableWindowMask - but windows are heavyweight so we're ok here
 }
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject val = JNFCallStaticObjectMethod(env, sjm_getAccessibleName, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
-return JNFJavaToNSString(env, val);
+if (val == NULL) {
+return @"unknown";
+}
+NSString* str = JNFJavaToNSString(env, val);
+(*env)->DeleteLocalRef(env, val);
+return str;
 }
 - (BOOL)accessibilityIsTitleAttributeSettable
 {
 return NO;
 // ask Java for the component's accessibleValue. In java, the "accessibleValue" just means a numerical value
 // a text value is taken care of in JavaTextAccessibility
 // cmcnote should coalesce these calls into one java call
+NSNumber *num = nil;
 jobject axValue = JNFCallStaticObjectMethod(env, sjm_getAccessibleValue, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
-return JNFJavaToNSNumber(env, JNFCallStaticObjectMethod(env, jm_getCurrentAccessibleValue, axValue, fComponent)); // AWT_THREADING Safe (AWTRunLoop)
+if (axValue != NULL) {
+jobject str = JNFCallStaticObjectMethod(env, jm_getCurrentAccessibleValue, axValue, fComponent);
+if (str != NULL) {
+num = JNFJavaToNSNumber(env, str); // AWT_THREADING Safe (AWTRunLoop)
+(*env)->DeleteLocalRef(env, str);
+}
+(*env)->DeleteLocalRef(env, axValue);
+}
+if (num == nil) {
+num = [NSNumber numberWithInt:0];
+}
+return num;
 }
 - (BOOL)accessibilityIsValueAttributeSettable
 {
 // according ot AppKit sources, in general the value attribute is not settable, except in the cases
 jobject jparent = fComponent;
 id value = nil;
 if (JNFIsInstanceOf(env, jparent, &jc_Container)) {
 jobject jaccessible = JNFCallStaticObjectMethod(env, jm_accessibilityHitTest, jparent, (jfloat)point.x, (jfloat)point.y); // AWT_THREADING Safe (AWTRunLoop)
-value = [JavaComponentAccessibility createWithAccessible:jaccessible withEnv:env withView:fView];
+if (jaccessible != NULL) {
+value = [JavaComponentAccessibility createWithAccessible:jaccessible withEnv:env withView:fView];
+(*env)->DeleteLocalRef(env, jaccessible);
+}
 }
 if (value == nil) {
 value = self;
 }
 if (focused != NULL) {
 if (JNFIsInstanceOf(env, focused, &sjc_Accessible)) {
 value = [JavaComponentAccessibility createWithAccessible:focused withEnv:env withView:fView];
 }
+(*env)->DeleteLocalRef(env, focused);
 }
 if (value == nil) {
 value = self;
 }
 JavaComponentAccessibility *aTab;
 NSInteger i;
 for (i = 0; i < _numTabs; i++) {
 aTab = (JavaComponentAccessibility *)[tabs objectAtIndex:i];
 if ([aTab isAccessibleWithEnv:env forAccessible:selAccessible]) {
+(*env)->DeleteLocalRef(env, selAccessible);
 return aTab;
 }
 }
+(*env)->DeleteLocalRef(env, selAccessible);
 return nil;
 }
 - (NSArray *)tabControlsWithEnv:(JNIEnv *)env withTabGroupAxContext:(jobject)axContext withTabCode:(NSInteger)whichTabs allowIgnored:(BOOL)allowIgnored
 {
-jobjectArray jtabsAndRoles = JNFCallStaticObjectMethod(env, jm_getChildrenAndRoles, fAccessible, fComponent, whichTabs, allowIgnored); // AWT_THREADING Safe (AWTRunLoop)
+jobjectArray jtabsAndRoles = (jobjectArray)JNFCallStaticObjectMethod(env, jm_getChildrenAndRoles, fAccessible, fComponent, whichTabs, allowIgnored); // AWT_THREADING Safe (AWTRunLoop)
 if(jtabsAndRoles == NULL) return nil;
 jsize arrayLen = (*env)->GetArrayLength(env, jtabsAndRoles);
-if (arrayLen == 0) return nil;
+if (arrayLen == 0) {
+(*env)->DeleteLocalRef(env, jtabsAndRoles);
+return nil;
+}
 NSMutableArray *tabs = [NSMutableArray arrayWithCapacity:(arrayLen/2)];
 // all of the tabs have the same role, so we can just find out what that is here and use it for all the tabs
 jobject jtabJavaRole = (*env)->GetObjectArrayElement(env, jtabsAndRoles, 1); // the array entries alternate between tab/role, starting with tab. so the first role is entry 1.
-if (jtabJavaRole == NULL) return nil;
+if (jtabJavaRole == NULL) {
+(*env)->DeleteLocalRef(env, jtabsAndRoles);
-NSString *tabJavaRole = JNFJavaToNSString(env, JNFGetObjectField(env, jtabJavaRole, sjf_key));
+return nil;
+}
+jobject jkey = JNFGetObjectField(env, jtabJavaRole, sjf_key);
+NSString *tabJavaRole = JNFJavaToNSString(env, jkey);
+(*env)->DeleteLocalRef(env, jkey);
 NSInteger i;
 NSUInteger tabIndex = (whichTabs >= 0) ? whichTabs : 0; // if we're getting one particular child, make sure to set its index correctly
 for(i = 0; i < arrayLen; i+=2) {
 jobject jtab = (*env)->GetObjectArrayElement(env, jtabsAndRoles, i);
 JavaComponentAccessibility *tab = [[[TabGroupControlAccessibility alloc] initWithParent:self withEnv:env withAccessible:jtab withIndex:tabIndex withTabGroup:axContext withView:[self view] withJavaRole:tabJavaRole] autorelease];
+(*env)->DeleteLocalRef(env, jtab);
 [tabs addObject:tab];
 tabIndex++;
 }
+(*env)->DeleteLocalRef(env, jtabsAndRoles);
 return tabs;
 }
 - (NSArray *)contentsWithEnv:(JNIEnv *)env withTabGroupAxContext:(jobject)axContext withTabCode:(NSInteger)whichTabs allowIgnored:(BOOL)allowIgnored
 {
 - (id) accessibilityTabsAttribute
 {
 JNIEnv *env = [ThreadUtilities getJNIEnv];
 jobject axContext = [self axContextWithEnv:env];
-return [self tabControlsWithEnv:env withTabGroupAxContext:axContext withTabCode:JAVA_AX_ALL_CHILDREN allowIgnored:NO];
+id tabs = [self tabControlsWithEnv:env withTabGroupAxContext:axContext withTabCode:JAVA_AX_ALL_CHILDREN allowIgnored:NO];
+(*env)->DeleteLocalRef(env, axContext);
+return tabs;
 }
 - (BOOL)accessibilityIsTabsAttributeSettable
 {
 return NO; //cmcnote: not sure.
 - (NSArray *) accessibilityContentsAttribute
 {
 JNIEnv *env = [ThreadUtilities getJNIEnv];
 jobject axContext = [self axContextWithEnv:env];
-return [self contentsWithEnv:env withTabGroupAxContext:axContext withTabCode:JAVA_AX_ALL_CHILDREN allowIgnored:NO];
+NSArray* cont = [self contentsWithEnv:env withTabGroupAxContext:axContext withTabCode:JAVA_AX_ALL_CHILDREN allowIgnored:NO];
+(*env)->DeleteLocalRef(env, axContext);
+return cont;
 }
 - (BOOL)accessibilityIsContentsAttributeSettable
 {
 return NO;
 // axValue is the currently selected tab
 -(id) accessibilityValueAttribute
 {
 JNIEnv *env = [ThreadUtilities getJNIEnv];
 jobject axContext = [self axContextWithEnv:env];
-return [self currentTabWithEnv:env withAxContext:axContext];
+id val = [self currentTabWithEnv:env withAxContext:axContext];
+(*env)->DeleteLocalRef(env, axContext);
+return val;
 }
 - (BOOL)accessibilityIsValueAttributeSettable
 {
 return YES;
 if (![number boolValue]) return;
 JNIEnv *env = [ThreadUtilities getJNIEnv];
 jobject axContext = [self axContextWithEnv:env];
 setAxContextSelection(env, axContext, fIndex, fComponent);
+(*env)->DeleteLocalRef(env, axContext);
 }
 - (NSArray *)accessibilityChildrenAttribute
 {
 //children = AXTabs + AXContents
 children= [self contentsWithEnv:env withTabGroupAxContext:axContext withTabCode:(index-[self numTabs]) allowIgnored:NO];
 if ([children count] > 0) {
 result = children;
 }
 }
+(*env)->DeleteLocalRef(env, axContext);
 } else {
 result = [super accessibilityArrayAttributeValues:attribute index:index maxCount:maxCount];
 }
 return result;
 }
 - (id)initWithParent:(NSObject *)parent withEnv:(JNIEnv *)env withAccessible:(jobject)accessible withIndex:(jint)index withTabGroup:(jobject)tabGroup withView:(NSView *)view withJavaRole:(NSString *)javaRole
 {
 self = [super initWithParent:parent withEnv:env withAccessible:accessible withIndex:index withView:view withJavaRole:javaRole];
 if (self) {
 if (tabGroup != NULL) {
-fTabGroupAxContext = JNFNewGlobalRef(env, tabGroup);
+fTabGroupAxContext = JNFNewWeakGlobalRef(env, tabGroup);
 } else {
 fTabGroupAxContext = NULL;
 }
 }
 return self;
 - (void)dealloc
 {
 JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 if (fTabGroupAxContext != NULL) {
-JNFDeleteGlobalRef(env, fTabGroupAxContext);
+JNFDeleteWeakGlobalRef(env, fTabGroupAxContext);
 fTabGroupAxContext = NULL;
 }
 [super dealloc];
 }
 - (id)accessibilityValueAttribute
 {
 JNIEnv *env = [ThreadUtilities getJNIEnv];
 jobject axContext = [self axContextWithEnv:env];
+jobject selAccessible = getAxContextSelection(env, [self tabGroup], fIndex, fComponent);
 // Returns the current selection of the page tab list
-return [NSNumber numberWithBool:ObjectEquals(env, axContext, getAxContextSelection(env, [self tabGroup], fIndex, fComponent), fComponent)];
+id val = [NSNumber numberWithBool:ObjectEquals(env, axContext, selAccessible, fComponent)];
+(*env)->DeleteLocalRef(env, selAccessible);
+(*env)->DeleteLocalRef(env, axContext);
+return val;
 }
 - (void)getActionsWithEnv:(JNIEnv *)env
 {
 TabGroupAction *action = [[TabGroupAction alloc] initWithEnv:env withTabGroup:[self tabGroup] withIndex:fIndex withComponent:fComponent];
 - (jobject)tabGroup
 {
 if (fTabGroupAxContext == NULL) {
 JNIEnv* env = [ThreadUtilities getJNIEnv];
 jobject tabGroupAxContext = [(JavaComponentAccessibility *)[self parent] axContextWithEnv:env];
-fTabGroupAxContext = JNFNewGlobalRef(env, tabGroupAxContext);
+fTabGroupAxContext = JNFNewWeakGlobalRef(env, tabGroupAxContext);
+(*env)->DeleteLocalRef(env, tabGroupAxContext);
 }
 return fTabGroupAxContext;
 }
 @end
 NSEnumerator *enumerator = [children objectEnumerator];
 while ((aElement = (JavaComponentAccessibility *)[enumerator nextObject])) {
 if ([[aElement accessibilityRoleAttribute] isEqualToString:NSAccessibilityScrollBarRole]) {
 jobject elementAxContext = [aElement axContextWithEnv:env];
 if (isHorizontal(env, elementAxContext, fComponent)) {
+(*env)->DeleteLocalRef(env, elementAxContext);
 return aElement;
 }
+(*env)->DeleteLocalRef(env, elementAxContext);
 }
 }
 return nil;
 }
 JavaComponentAccessibility *aElement;
 while ((aElement = (JavaComponentAccessibility *)[enumerator nextObject])) {
 if ([[aElement accessibilityRoleAttribute] isEqualToString:NSAccessibilityScrollBarRole]) {
 jobject elementAxContext = [aElement axContextWithEnv:env];
 if (isVertical(env, elementAxContext, fComponent)) {
+(*env)->DeleteLocalRef(env, elementAxContext);
 return aElement;
 }
+(*env)->DeleteLocalRef(env, elementAxContext);
 }
 }
 return nil;
 }

changeset 37787	de878aeb7ed2
parent 26751	70bac69b37c9
child 38408	3c80511b8982