Snap for 8211684 from ee26c50f8427c9ec8e9c71db209113aa3a568730 to tm-preview2-release
Change-Id: Ief138020829052988259da010ce259d90b1cbf9c
diff --git a/dalvik/src/main/java/dalvik/system/ZygoteHooks.java b/dalvik/src/main/java/dalvik/system/ZygoteHooks.java
index cc7a8d7..bfe1945 100644
--- a/dalvik/src/main/java/dalvik/system/ZygoteHooks.java
+++ b/dalvik/src/main/java/dalvik/system/ZygoteHooks.java
@@ -31,6 +31,9 @@
import java.lang.ReflectiveOperationException;
import libcore.icu.SimpleDateFormatData;
+import sun.util.locale.BaseLocale;
+import java.util.Locale;
+
/**
* Provides hooks for the zygote to call back into the runtime to perform
* parent or child specific initialization..
@@ -99,6 +102,16 @@
}
/**
+ * Called after GC but before fork, it cleans stale cache entries in
+ * BaseLocale and Locale, so to avoid the cleaning to happen in every
+ * child process.
+ */
+ private static void cleanLocaleCaches() {
+ BaseLocale.cleanCache();
+ Locale.cleanCache();
+ }
+
+ /**
* Runs several special GCs to try to clean up a few generations of
* softly- and final-reachable objects, along with any other garbage.
* This is only useful just before a fork().
@@ -114,6 +127,7 @@
*/
System.gc();
runtime.runFinalizationSync();
+ cleanLocaleCaches();
System.gc();
}
diff --git a/ojluni/src/main/java/java/lang/invoke/Transformers.java b/ojluni/src/main/java/java/lang/invoke/Transformers.java
index eca1a30..40b7d6f 100644
--- a/ojluni/src/main/java/java/lang/invoke/Transformers.java
+++ b/ojluni/src/main/java/java/lang/invoke/Transformers.java
@@ -106,18 +106,11 @@
}
}
- /**
- * A method handle that always throws an exception of a specified type.
- *
- * <p>The handle declares a nominal return type, which is immaterial to the execution of the
- * handle because it never returns.
- *
- * @hide
- */
- public static class AlwaysThrow extends Transformer {
+ /** Implements {@code MethodHandles.throwException}. */
+ static class AlwaysThrow extends Transformer {
private final Class<? extends Throwable> exceptionType;
- public AlwaysThrow(Class<?> nominalReturnType, Class<? extends Throwable> exType) {
+ AlwaysThrow(Class<?> nominalReturnType, Class<? extends Throwable> exType) {
super(MethodType.methodType(nominalReturnType, exType));
this.exceptionType = exType;
}
@@ -129,12 +122,12 @@
}
/** Implements {@code MethodHandles.dropArguments}. */
- public static class DropArguments extends Transformer {
+ static class DropArguments extends Transformer {
private final MethodHandle delegate;
private final EmulatedStackFrame.Range range1;
private final EmulatedStackFrame.Range range2;
- public DropArguments(MethodType type, MethodHandle delegate, int startPos, int numDropped) {
+ DropArguments(MethodType type, MethodHandle delegate, int startPos, int numDropped) {
super(type);
this.delegate = delegate;
@@ -160,14 +153,14 @@
}
/** Implements {@code MethodHandles.catchException}. */
- public static class CatchException extends Transformer {
+ static class CatchException extends Transformer {
private final MethodHandle target;
private final MethodHandle handler;
private final Class<?> exType;
private final EmulatedStackFrame.Range handlerArgsRange;
- public CatchException(MethodHandle target, MethodHandle handler, Class<?> exType) {
+ CatchException(MethodHandle target, MethodHandle handler, Class<?> exType) {
super(target.type());
this.target = target;
@@ -216,14 +209,14 @@
}
/** Implements {@code MethodHandles.tryFinally}. */
- public static class TryFinally extends Transformer {
+ static class TryFinally extends Transformer {
/** The target handle to try. */
private final MethodHandle target;
/** The cleanup handle to invoke after the target. */
private final MethodHandle cleanup;
- public TryFinally(MethodHandle target, MethodHandle cleanup) {
+ TryFinally(MethodHandle target, MethodHandle cleanup) {
super(target.type());
this.target = target;
this.cleanup = cleanup;
@@ -280,14 +273,14 @@
}
/** Implements {@code MethodHandles.GuardWithTest}. */
- public static class GuardWithTest extends Transformer {
+ static class GuardWithTest extends Transformer {
private final MethodHandle test;
private final MethodHandle target;
private final MethodHandle fallback;
private final EmulatedStackFrame.Range testArgsRange;
- public GuardWithTest(MethodHandle test, MethodHandle target, MethodHandle fallback) {
+ GuardWithTest(MethodHandle test, MethodHandle target, MethodHandle fallback) {
super(target.type());
this.test = test;
@@ -318,11 +311,11 @@
}
}
- /** Implementation of MethodHandles.arrayElementGetter for reference types. */
- public static class ReferenceArrayElementGetter extends Transformer {
+ /** Implements {@code MethodHandles.arrayElementGetter}. */
+ static class ReferenceArrayElementGetter extends Transformer {
private final Class<?> arrayClass;
- public ReferenceArrayElementGetter(Class<?> arrayClass) {
+ ReferenceArrayElementGetter(Class<?> arrayClass) {
super(
MethodType.methodType(
arrayClass.getComponentType(), new Class<?>[] {arrayClass, int.class}));
@@ -346,11 +339,11 @@
}
}
- /** Implementation of MethodHandles.arrayElementSetter for reference types. */
- public static class ReferenceArrayElementSetter extends Transformer {
+ /** Implements {@code MethodHandles.arrayElementSetter}. */
+ static class ReferenceArrayElementSetter extends Transformer {
private final Class<?> arrayClass;
- public ReferenceArrayElementSetter(Class<?> arrayClass) {
+ ReferenceArrayElementSetter(Class<?> arrayClass) {
super(
MethodType.methodType(
void.class,
@@ -372,11 +365,11 @@
}
}
- /** Implementation of MethodHandles.identity() for reference types. */
- public static class ReferenceIdentity extends Transformer {
+ /** Implements {@code MethodHandles.identity}. */
+ static class ReferenceIdentity extends Transformer {
private final Class<?> type;
- public ReferenceIdentity(Class<?> type) {
+ ReferenceIdentity(Class<?> type) {
super(MethodType.methodType(type, type));
this.type = type;
}
@@ -393,7 +386,8 @@
}
}
- public static class ZeroValue extends Transformer {
+ /** Implements {@code MethodHandles.makeZero}. */
+ static class ZeroValue extends Transformer {
public ZeroValue(Class<?> type) {
super(MethodType.methodType(type));
}
@@ -404,10 +398,11 @@
}
}
- public static class ArrayConstructor extends Transformer {
+ /** Implements {@code MethodHandles.arrayConstructor}. */
+ static class ArrayConstructor extends Transformer {
private final Class<?> componentType;
- public ArrayConstructor(Class<?> arrayType) {
+ ArrayConstructor(Class<?> arrayType) {
super(MethodType.methodType(arrayType, int.class));
componentType = arrayType.getComponentType();
}
@@ -422,10 +417,11 @@
}
}
- public static class ArrayLength extends Transformer {
+ /** Implements {@code MethodHandles.arrayLength}. */
+ static class ArrayLength extends Transformer {
private final Class<?> arrayType;
- public ArrayLength(Class<?> arrayType) {
+ ArrayLength(Class<?> arrayType) {
super(MethodType.methodType(int.class, arrayType));
this.arrayType = arrayType;
}
@@ -474,11 +470,13 @@
writer.putNextInt(length);
}
}
- /*package*/ static class Construct extends Transformer {
+
+ /** Implements {@code MethodHandles.createMethodHandleForConstructor}. */
+ static class Construct extends Transformer {
private final MethodHandle constructorHandle;
private final EmulatedStackFrame.Range callerRange;
- /*package*/ Construct(MethodHandle constructorHandle, MethodType returnedType) {
+ Construct(MethodHandle constructorHandle, MethodType returnedType) {
super(returnedType);
this.constructorHandle = constructorHandle;
this.callerRange = EmulatedStackFrame.Range.all(type());
@@ -523,18 +521,14 @@
}
}
- /**
- * Implements MethodHandle.bindTo.
- *
- * @hide
- */
- public static class BindTo extends Transformer {
+ /** Implements {@code MethodHandle.bindTo}. */
+ static class BindTo extends Transformer {
private final MethodHandle delegate;
private final Object receiver;
private final EmulatedStackFrame.Range range;
- public BindTo(MethodHandle delegate, Object receiver) {
+ BindTo(MethodHandle delegate, Object receiver) {
super(delegate.type().dropParameterTypes(0, 1));
this.delegate = delegate;
@@ -561,14 +555,14 @@
}
}
- /** Implements MethodHandle.filterReturnValue. */
- public static class FilterReturnValue extends Transformer {
+ /** Implements {@code MethodHandle.filterReturnValue}. */
+ static class FilterReturnValue extends Transformer {
private final MethodHandle target;
private final MethodHandle filter;
private final EmulatedStackFrame.Range allArgs;
- public FilterReturnValue(MethodHandle target, MethodHandle filter) {
+ FilterReturnValue(MethodHandle target, MethodHandle filter) {
super(MethodType.methodType(filter.type().rtype(), target.type().ptypes()));
this.target = target;
@@ -605,16 +599,12 @@
}
}
- /*
- * Implements MethodHandles.permuteArguments.
- *
- * @hide
- */
- public static class PermuteArguments extends Transformer {
+ /** Implements {@code MethodHandles.permuteArguments}. */
+ static class PermuteArguments extends Transformer {
private final MethodHandle target;
private final int[] reorder;
- public PermuteArguments(MethodType type, MethodHandle target, int[] reorder) {
+ PermuteArguments(MethodType type, MethodHandle target, int[] reorder) {
super(type);
this.target = target;
@@ -642,16 +632,12 @@
}
}
- /**
- * Makes a variable-arity adapter that groups trailing varargs arguments into an array.
- *
- * @hide
- */
- /*package*/ static class VarargsCollector extends Transformer {
+ /** Implements {@code MethodHandle.asVarargsCollector}. */
+ static class VarargsCollector extends Transformer {
final MethodHandle target;
private final Class<?> arrayType;
- /*package*/ VarargsCollector(MethodHandle target) {
+ VarargsCollector(MethodHandle target) {
super(target.type());
Class<?>[] parameterTypes = target.type().ptypes();
@@ -1179,7 +1165,7 @@
}
}
- /** Implements MethodHandles.invoker & MethodHandles.exactInvoker. */
+ /** Implements {@code MethodHandles.invoker} and {@code MethodHandles.exactInvoker}. */
static class Invoker extends Transformer {
private final MethodType targetType;
private final boolean isExactInvoker;
@@ -1252,7 +1238,7 @@
}
}
- /** Implements MethodHandle.asSpreader / MethodHandles.spreadInvoker. */
+ /** Implements {@code MethodHandle.asSpreader}. */
static class Spreader extends Transformer {
/** The method handle we're delegating to. */
private final MethodHandle target;
@@ -1414,7 +1400,7 @@
}
}
- /** Implements MethodHandle.asCollector. */
+ /** Implements {@code MethodHandle.asCollector}. */
static class Collector extends Transformer {
private final MethodHandle target;
@@ -1568,9 +1554,7 @@
}
}
- /*
- * Implements MethodHandles.filterArguments.
- */
+ /** Implements {@code MethodHandles.filterArguments}. */
static class FilterArguments extends Transformer {
/** The target handle. */
private final MethodHandle target;
@@ -1648,7 +1632,7 @@
}
}
- /** Implements MethodHandles.collectArguments. */
+ /** Implements {@code MethodHandles.collectArguments}. */
static class CollectArguments extends Transformer {
private final MethodHandle target;
private final MethodHandle collector;
@@ -1732,7 +1716,7 @@
}
}
- /** Implements MethodHandles.foldArguments. */
+ /** Implements {@code MethodHandles.foldArguments}. */
static class FoldArguments extends Transformer {
private final MethodHandle target;
private final MethodHandle combiner;
@@ -1822,7 +1806,7 @@
}
}
- /** Implements MethodHandles.insertArguments. */
+ /** Implements {@code MethodHandles.insertArguments}. */
static class InsertArguments extends Transformer {
private final MethodHandle target;
private final int pos;
@@ -1909,10 +1893,11 @@
}
}
- public static class AsTypeAdapter extends Transformer {
+ /** Implements {@code MethodHandle.asType}. */
+ static class AsTypeAdapter extends Transformer {
private final MethodHandle target;
- public AsTypeAdapter(MethodHandle target, MethodType type) {
+ AsTypeAdapter(MethodHandle target, MethodType type) {
super(type);
this.target = target;
}
@@ -2298,11 +2283,11 @@
}
}
- /** Implements {@link java.lang.invokeMethodHandles#explicitCastArguments()}. */
- public static class ExplicitCastArguments extends Transformer {
+ /** Implements {@code MethodHandles.explicitCastArguments}. */
+ static class ExplicitCastArguments extends Transformer {
private final MethodHandle target;
- public ExplicitCastArguments(MethodHandle target, MethodType type) {
+ ExplicitCastArguments(MethodHandle target, MethodType type) {
super(type);
this.target = target;
}
@@ -2966,10 +2951,8 @@
}
}
- /**
- * Implements transform for use by MethodHandles.loop().
- */
- public static class Loop extends Transformer {
+ /** Implements {@code MethodHandles.loop}. */
+ static class Loop extends Transformer {
/** Loop variable initialization methods. */
final MethodHandle[] inits;
diff --git a/ojluni/src/main/java/java/security/IdentityScope.java b/ojluni/src/main/java/java/security/IdentityScope.java
index 61d37cb..9dddd56 100644
--- a/ojluni/src/main/java/java/security/IdentityScope.java
+++ b/ojluni/src/main/java/java/security/IdentityScope.java
@@ -63,6 +63,8 @@
* {@code java.security.Principal}.
*/
@Deprecated
+// Android-added: Identity is deprecated too, no need to warn here.
+@SuppressWarnings("removal")
public abstract
class IdentityScope extends Identity {
diff --git a/ojluni/src/main/java/java/util/Locale.java b/ojluni/src/main/java/java/util/Locale.java
index 80f9ed7..ffa8b71 100644
--- a/ojluni/src/main/java/java/util/Locale.java
+++ b/ojluni/src/main/java/java/util/Locale.java
@@ -837,6 +837,19 @@
return LOCALECACHE.get(key);
}
+ // BEGIN Android-added: Add a static method to clear the stale entries in Zygote
+ /**
+ * This method cleans the stale entries in LOCALECACHE. This would
+ * be called in Zygote after GC but before fork, and so to avoid the
+ * cleaning of the cache to happen in child processes.
+ *
+ * @hide
+ */
+ public static void cleanCache() {
+ LOCALECACHE.cleanStaleEntries();
+ }
+ // END Android-added: Add a static method to clear the stale entries in Zygote
+
private static class Cache extends LocaleObjectCache<LocaleKey, Locale> {
private Cache() {
}
diff --git a/ojluni/src/main/java/sun/util/locale/BaseLocale.java b/ojluni/src/main/java/sun/util/locale/BaseLocale.java
index e0e9ed0..c037d67 100644
--- a/ojluni/src/main/java/sun/util/locale/BaseLocale.java
+++ b/ojluni/src/main/java/sun/util/locale/BaseLocale.java
@@ -164,6 +164,19 @@
return h;
}
+ // BEGIN Android-added: Add a static method to clear the stale entries in Zygote
+ /**
+ * This method cleans the stale entries in BaseLocale.CACHE. This would
+ * be called in Zygote after GC but before fork, and so to avoid the
+ * cleaning of the cache to happen in child processes.
+ *
+ * @hide
+ */
+ public static void cleanCache() {
+ CACHE.cleanStaleEntries();
+ }
+ // END Android-added: Add a static method to clear the stale entries in Zygote
+
private static final class Key {
private final SoftReference<String> lang;
private final SoftReference<String> scrt;
diff --git a/ojluni/src/main/java/sun/util/locale/LocaleObjectCache.java b/ojluni/src/main/java/sun/util/locale/LocaleObjectCache.java
index eae1480..f859966 100644
--- a/ojluni/src/main/java/sun/util/locale/LocaleObjectCache.java
+++ b/ojluni/src/main/java/sun/util/locale/LocaleObjectCache.java
@@ -88,8 +88,9 @@
return (oldEntry == null) ? null : oldEntry.get();
}
+ // Android-changed: Make it public / protected to clean stale entries before Zygote forks
@SuppressWarnings("unchecked")
- private void cleanStaleEntries() {
+ public void cleanStaleEntries() {
CacheEntry<K, V> entry;
while ((entry = (CacheEntry<K, V>)queue.poll()) != null) {
map.remove(entry.getKey());
diff --git a/ojluni/src/test/java/net/SocketOptions/MinimumRcvBufferSize.java b/ojluni/src/test/java/net/SocketOptions/MinimumRcvBufferSize.java
index 767058f..a2f333e 100644
--- a/ojluni/src/test/java/net/SocketOptions/MinimumRcvBufferSize.java
+++ b/ojluni/src/test/java/net/SocketOptions/MinimumRcvBufferSize.java
@@ -38,29 +38,24 @@
@Test
public void testBufferSize() throws Exception {
- boolean error = false;
- // BEGIN Android-removed: failing in Cuttlefish (b/218814458).
- /*
ServerSocketChannel channel = ServerSocketChannel.open();
+ // Android-added: set initial buffersize to zero (b/218814458)
+ channel.setOption(StandardSocketOptions.SO_RCVBUF, 0);
int before = channel.getOption(StandardSocketOptions.SO_RCVBUF);
channel.setOption(StandardSocketOptions.SO_RCVBUF, Integer.MAX_VALUE);
int after = channel.getOption(StandardSocketOptions.SO_RCVBUF);
if (before > after) {
- fail("Test failed: SO_RCVBUF");
- error = true;
+ fail("Test failed: SO_RCVBUF: " + before + " " + after);
}
- */
- // END Android-removed: failing in Cuttlefish (b/218814458).
SocketChannel channel1 = SocketChannel.open();
- int before = channel1.getOption(StandardSocketOptions.SO_SNDBUF);
+ // Android-added: set initial buffersize to zero (b/218814458)
+ channel1.setOption(StandardSocketOptions.SO_SNDBUF, 0);
+ before = channel1.getOption(StandardSocketOptions.SO_SNDBUF);
channel1.setOption(StandardSocketOptions.SO_SNDBUF, Integer.MAX_VALUE);
- int after = channel1.getOption(StandardSocketOptions.SO_SNDBUF);
+ after = channel1.getOption(StandardSocketOptions.SO_SNDBUF);
if (before > after) {
- fail("Test failed: SO_SNDBUF");
- error = true;
+ fail("Test failed: SO_SNDBUF: " + before + " " + after);
}
- if (error)
- throw new RuntimeException("Test failed");
}
}
\ No newline at end of file
