Add stubs for hiddenapi

Adds stubs for ojluni classes some of whose hidden members are used by
applications. Each such member is annotated with the UnsupportedAppUsage
annotation.

The stubs are built as part of the core-oj-hiddenapi target from which
the build will extract information about the hidden class members that
are used by applications.

This was tested by making and then manually checking that the generated
out/target/common/obj/PACKAGING/hiddenapi-light-greylist.txt was the
same (after sorting) before and after this change.

Test: see above
Bug: 117818301
Change-Id: Icfe773e00ba1f96a379b705f26ef631ec34fee5e

1 files changed, 525 insertions, 0 deletions

diff --git a/ojluni/annotations/hiddenapi/java/lang/Thread.java b/ojluni/annotations/hiddenapi/java/lang/Thread.java
new file mode 100644
index 0000000000..aade5930d1
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Thread.java
@@ -0,0 +1,525 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Thread implements java.lang.Runnable {
+
+    public Thread() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Thread(java.lang.Runnable target) {
+        throw new RuntimeException("Stub!");
+    }
+
+    Thread(java.lang.Runnable target, java.security.AccessControlContext acc) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Thread(java.lang.ThreadGroup group, java.lang.Runnable target) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Thread(java.lang.String name) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Thread(java.lang.ThreadGroup group, java.lang.String name) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @UnsupportedAppUsage
+    Thread(java.lang.ThreadGroup group, java.lang.String name, int priority, boolean daemon) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Thread(java.lang.Runnable target, java.lang.String name) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Thread(java.lang.ThreadGroup group, java.lang.Runnable target, java.lang.String name) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Thread(
+            java.lang.ThreadGroup group,
+            java.lang.Runnable target,
+            java.lang.String name,
+            long stackSize) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static synchronized int nextThreadNum() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static synchronized long nextThreadID() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void blockedOn(sun.nio.ch.Interruptible b) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static native java.lang.Thread currentThread();
+
+    public static native void yield();
+
+    public static void sleep(long millis) throws java.lang.InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static native void sleep(java.lang.Object lock, long millis, int nanos)
+            throws java.lang.InterruptedException;
+
+    public static void sleep(long millis, int nanos) throws java.lang.InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void init(
+            java.lang.ThreadGroup g,
+            java.lang.Runnable target,
+            java.lang.String name,
+            long stackSize) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void init(
+            java.lang.ThreadGroup g,
+            java.lang.Runnable target,
+            java.lang.String name,
+            long stackSize,
+            java.security.AccessControlContext acc) {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected java.lang.Object clone() throws java.lang.CloneNotSupportedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void init2(java.lang.Thread parent) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void start() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static native void nativeCreate(java.lang.Thread t, long stackSize, boolean daemon);
+
+    public void run() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void exit() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Deprecated
+    public final void stop() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Deprecated
+    public final synchronized void stop(java.lang.Throwable obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void interrupt() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static native boolean interrupted();
+
+    public native boolean isInterrupted();
+
+    @Deprecated
+    public void destroy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final boolean isAlive() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Deprecated
+    public final void suspend() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Deprecated
+    public final void resume() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void setPriority(int newPriority) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final int getPriority() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized void setName(java.lang.String name) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final java.lang.String getName() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final java.lang.ThreadGroup getThreadGroup() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int activeCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int enumerate(java.lang.Thread[] tarray) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Deprecated
+    public int countStackFrames() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void join(long millis) throws java.lang.InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void join(long millis, int nanos) throws java.lang.InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void join() throws java.lang.InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void dumpStack() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void setDaemon(boolean on) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final boolean isDaemon() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void checkAccess() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public java.lang.String toString() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public java.lang.ClassLoader getContextClassLoader() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setContextClassLoader(java.lang.ClassLoader cl) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static native boolean holdsLock(java.lang.Object obj);
+
+    public java.lang.StackTraceElement[] getStackTrace() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.Map<java.lang.Thread, java.lang.StackTraceElement[]>
+            getAllStackTraces() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static boolean isCCLOverridden(java.lang.Class<?> cl) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static boolean auditSubclass(java.lang.Class<?> subcl) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public long getId() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public java.lang.Thread.State getState() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void setDefaultUncaughtExceptionHandler(
+            java.lang.Thread.UncaughtExceptionHandler eh) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void setUncaughtExceptionPreHandler(
+            java.lang.Thread.UncaughtExceptionHandler eh) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @UnsupportedAppUsage
+    public static java.lang.Thread.UncaughtExceptionHandler getUncaughtExceptionPreHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public java.lang.Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler eh) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @UnsupportedAppUsage
+    public final void dispatchUncaughtException(java.lang.Throwable e) {
+        throw new RuntimeException("Stub!");
+    }
+
+    static void processQueue(
+            java.lang.ref.ReferenceQueue<java.lang.Class<?>> queue,
+            java.util.concurrent.ConcurrentMap<
+                            ? extends java.lang.ref.WeakReference<java.lang.Class<?>>, ?>
+                    map) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private native void setPriority0(int newPriority);
+
+    private native void interrupt0();
+
+    private native void setNativeName(java.lang.String name);
+
+    private native int nativeGetStatus(boolean hasBeenStarted);
+
+    public final void unpark$() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void parkFor$(long nanos) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void parkUntil$(long time) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static final java.lang.StackTraceElement[] EMPTY_STACK_TRACE;
+
+    static {
+        EMPTY_STACK_TRACE = new java.lang.StackTraceElement[0];
+    }
+
+    public static final int MAX_PRIORITY = 10; // 0xa
+
+    public static final int MIN_PRIORITY = 1; // 0x1
+
+    private static final int NANOS_PER_MILLI = 1000000; // 0xf4240
+
+    public static final int NORM_PRIORITY = 5; // 0x5
+
+    private static final java.lang.RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION;
+
+    static {
+        SUBCLASS_IMPLEMENTATION_PERMISSION = null;
+    }
+
+    private volatile sun.nio.ch.Interruptible blocker;
+
+    private final java.lang.Object blockerLock;
+
+    {
+        blockerLock = null;
+    }
+
+    @UnsupportedAppUsage
+    private java.lang.ClassLoader contextClassLoader;
+
+    @UnsupportedAppUsage
+    private boolean daemon = false;
+
+    private static volatile java.lang.Thread.UncaughtExceptionHandler
+            defaultUncaughtExceptionHandler;
+
+    private long eetop;
+
+    @UnsupportedAppUsage
+    private java.lang.ThreadGroup group;
+
+    @UnsupportedAppUsage
+    java.lang.ThreadLocal.ThreadLocalMap inheritableThreadLocals;
+
+    @UnsupportedAppUsage
+    private java.security.AccessControlContext inheritedAccessControlContext;
+
+    @UnsupportedAppUsage
+    private final java.lang.Object lock;
+
+    {
+        lock = null;
+    }
+
+    @UnsupportedAppUsage
+    private volatile java.lang.String name;
+
+    private long nativeParkEventPointer;
+
+    @UnsupportedAppUsage
+    private volatile long nativePeer;
+
+    @UnsupportedAppUsage
+    volatile java.lang.Object parkBlocker;
+
+    private int parkState = 1; // 0x1
+
+    @UnsupportedAppUsage
+    private int priority;
+
+    private boolean single_step;
+
+    private long stackSize;
+
+    boolean started = false;
+
+    private boolean stillborn = false;
+
+    @UnsupportedAppUsage
+    private java.lang.Runnable target;
+
+    private static int threadInitNumber;
+
+    int threadLocalRandomProbe;
+
+    int threadLocalRandomSecondarySeed;
+
+    long threadLocalRandomSeed;
+
+    @UnsupportedAppUsage
+    java.lang.ThreadLocal.ThreadLocalMap threadLocals;
+
+    private java.lang.Thread threadQ;
+
+    @UnsupportedAppUsage
+    private static long threadSeqNumber;
+
+    private long tid;
+
+    private volatile java.lang.Thread.UncaughtExceptionHandler uncaughtExceptionHandler;
+
+    private static volatile java.lang.Thread.UncaughtExceptionHandler uncaughtExceptionPreHandler;
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private static class Caches {
+
+        private Caches() {
+            throw new RuntimeException("Stub!");
+        }
+
+        static final java.util.concurrent.ConcurrentMap<
+                        java.lang.Thread.WeakClassKey, java.lang.Boolean>
+                subclassAudits;
+
+        static {
+            subclassAudits = null;
+        }
+
+        static final java.lang.ref.ReferenceQueue<java.lang.Class<?>> subclassAuditsQueue;
+
+        static {
+            subclassAuditsQueue = null;
+        }
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private static class ParkState {
+
+        private ParkState() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private static final int PARKED = 3; // 0x3
+
+        private static final int PREEMPTIVELY_UNPARKED = 2; // 0x2
+
+        private static final int UNPARKED = 1; // 0x1
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    public static enum State {
+        NEW,
+        RUNNABLE,
+        BLOCKED,
+        WAITING,
+        TIMED_WAITING,
+        TERMINATED;
+
+        private State() {
+            throw new RuntimeException("Stub!");
+        }
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    public static interface UncaughtExceptionHandler {
+
+        public void uncaughtException(java.lang.Thread t, java.lang.Throwable e);
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    static class WeakClassKey extends java.lang.ref.WeakReference<java.lang.Class<?>> {
+
+        WeakClassKey(
+                java.lang.Class<?> cl, java.lang.ref.ReferenceQueue<java.lang.Class<?>> refQueue) {
+            super(null);
+            throw new RuntimeException("Stub!");
+        }
+
+        public int hashCode() {
+            throw new RuntimeException("Stub!");
+        }
+
+        public boolean equals(java.lang.Object obj) {
+            throw new RuntimeException("Stub!");
+        }
+
+        private final int hash;
+
+        {
+            hash = 0;
+        }
+    }
+}