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, 745 insertions, 0 deletions

diff --git a/ojluni/annotations/hiddenapi/java/io/ObjectOutputStream.java b/ojluni/annotations/hiddenapi/java/io/ObjectOutputStream.java
new file mode 100644
index 0000000000..f3e462d671
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/ObjectOutputStream.java
@@ -0,0 +1,745 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 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.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ObjectOutputStream extends java.io.OutputStream
+        implements java.io.ObjectOutput, java.io.ObjectStreamConstants {
+
+    public ObjectOutputStream(java.io.OutputStream out) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected ObjectOutputStream() throws java.io.IOException, java.lang.SecurityException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void useProtocolVersion(int version) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void writeObject(java.lang.Object obj) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected void writeObjectOverride(java.lang.Object obj) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeUnshared(java.lang.Object obj) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void defaultWriteObject() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public java.io.ObjectOutputStream.PutField putFields() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeFields() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void reset() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected void annotateClass(java.lang.Class<?> cl) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected void annotateProxyClass(java.lang.Class<?> cl) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected java.lang.Object replaceObject(java.lang.Object obj) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected boolean enableReplaceObject(boolean enable) throws java.lang.SecurityException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected void writeStreamHeader() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected void writeClassDescriptor(java.io.ObjectStreamClass desc) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void write(int val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void write(byte[] buf) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void write(byte[] buf, int off, int len) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void flush() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    protected void drain() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void close() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeBoolean(boolean val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeByte(int val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeShort(int val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeChar(int val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeInt(int val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeLong(long val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeFloat(float val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeDouble(double val) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeBytes(java.lang.String str) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeChars(java.lang.String str) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void writeUTF(java.lang.String str) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    int getProtocolVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    void writeTypeString(java.lang.String str) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void verifySubclass() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static boolean auditSubclass(java.lang.Class<?> subcl) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void clear() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeObject0(java.lang.Object obj, boolean unshared) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeNull() throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeHandle(int handle) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeClass(java.lang.Class<?> cl, boolean unshared) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeClassDesc(java.io.ObjectStreamClass desc, boolean unshared)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private boolean isCustomSubclass() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeProxyDesc(java.io.ObjectStreamClass desc, boolean unshared)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeNonProxyDesc(java.io.ObjectStreamClass desc, boolean unshared)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeString(java.lang.String str, boolean unshared) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeArray(
+            java.lang.Object array, java.io.ObjectStreamClass desc, boolean unshared)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeEnum(java.lang.Enum<?> en, java.io.ObjectStreamClass desc, boolean unshared)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeOrdinaryObject(
+            java.lang.Object obj, java.io.ObjectStreamClass desc, boolean unshared)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeExternalData(java.io.Externalizable obj) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeSerialData(java.lang.Object obj, java.io.ObjectStreamClass desc)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void defaultWriteFields(java.lang.Object obj, java.io.ObjectStreamClass desc)
+            throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private void writeFatalException(java.io.IOException ex) throws java.io.IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static native void floatsToBytes(
+            float[] src, int srcpos, byte[] dst, int dstpos, int nfloats);
+
+    private static native void doublesToBytes(
+            double[] src, int srcpos, byte[] dst, int dstpos, int ndoubles);
+
+    private final java.io.ObjectOutputStream.BlockDataOutputStream bout;
+
+    {
+        bout = null;
+    }
+
+    private java.io.SerialCallbackContext curContext;
+
+    private java.io.ObjectOutputStream.PutFieldImpl curPut;
+
+    private final java.io.ObjectOutputStream.DebugTraceInfoStack debugInfoStack;
+
+    {
+        debugInfoStack = null;
+    }
+
+    private int depth;
+
+    private final boolean enableOverride;
+
+    {
+        enableOverride = false;
+    }
+
+    private boolean enableReplace;
+
+    private static final boolean extendedDebugInfo = false;
+
+    private final java.io.ObjectOutputStream.HandleTable handles;
+
+    {
+        handles = null;
+    }
+
+    private byte[] primVals;
+
+    @UnsupportedAppUsage
+    private int protocol = 2; // 0x2
+
+    private final java.io.ObjectOutputStream.ReplaceTable subs;
+
+    {
+        subs = null;
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private static class BlockDataOutputStream extends java.io.OutputStream
+            implements java.io.DataOutput {
+
+        BlockDataOutputStream(java.io.OutputStream out) {
+            throw new RuntimeException("Stub!");
+        }
+
+        boolean setBlockDataMode(boolean mode) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        boolean getBlockDataMode() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private void warnIfClosed() {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void write(int b) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void write(byte[] b) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void write(byte[] b, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void flush() throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void close() throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void write(byte[] b, int off, int len, boolean copy) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void drain() throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        private void writeBlockHeader(int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeBoolean(boolean v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeByte(int v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeChar(int v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeShort(int v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeInt(int v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeFloat(float v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeLong(long v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeDouble(double v) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeBytes(java.lang.String s) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeChars(java.lang.String s) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void writeUTF(java.lang.String s) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeBooleans(boolean[] v, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeChars(char[] v, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeShorts(short[] v, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeInts(int[] v, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeFloats(float[] v, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeLongs(long[] v, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeDoubles(double[] v, int off, int len) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        long getUTFLength(java.lang.String s) {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeUTF(java.lang.String s, long utflen) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeLongUTF(java.lang.String s) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeLongUTF(java.lang.String s, long utflen) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        private void writeUTFBody(java.lang.String s) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        private static final int CHAR_BUF_SIZE = 256; // 0x100
+
+        private static final int MAX_BLOCK_SIZE = 1024; // 0x400
+
+        private static final int MAX_HEADER_SIZE = 5; // 0x5
+
+        private boolean blkmode = false;
+
+        private final byte[] buf;
+
+        {
+            buf = new byte[0];
+        }
+
+        private final char[] cbuf;
+
+        {
+            cbuf = new char[0];
+        }
+
+        private final java.io.DataOutputStream dout;
+
+        {
+            dout = null;
+        }
+
+        private final byte[] hbuf;
+
+        {
+            hbuf = new byte[0];
+        }
+
+        private final java.io.OutputStream out;
+
+        {
+            out = null;
+        }
+
+        private int pos = 0; // 0x0
+
+        private boolean warnOnceWhenWriting;
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private static class Caches {
+
+        private Caches() {
+            throw new RuntimeException("Stub!");
+        }
+
+        static final java.util.concurrent.ConcurrentMap<
+                        java.io.ObjectStreamClass.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 DebugTraceInfoStack {
+
+        DebugTraceInfoStack() {
+            throw new RuntimeException("Stub!");
+        }
+
+        void clear() {
+            throw new RuntimeException("Stub!");
+        }
+
+        void pop() {
+            throw new RuntimeException("Stub!");
+        }
+
+        void push(java.lang.String entry) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public java.lang.String toString() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private final java.util.List<java.lang.String> stack;
+
+        {
+            stack = null;
+        }
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private static class HandleTable {
+
+        HandleTable(int initialCapacity, float loadFactor) {
+            throw new RuntimeException("Stub!");
+        }
+
+        int assign(java.lang.Object obj) {
+            throw new RuntimeException("Stub!");
+        }
+
+        int lookup(java.lang.Object obj) {
+            throw new RuntimeException("Stub!");
+        }
+
+        void clear() {
+            throw new RuntimeException("Stub!");
+        }
+
+        int size() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private void insert(java.lang.Object obj, int handle) {
+            throw new RuntimeException("Stub!");
+        }
+
+        private void growSpine() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private void growEntries() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private int hash(java.lang.Object obj) {
+            throw new RuntimeException("Stub!");
+        }
+
+        private final float loadFactor;
+
+        {
+            loadFactor = 0;
+        }
+
+        private int[] next;
+
+        private java.lang.Object[] objs;
+
+        private int size;
+
+        private int[] spine;
+
+        private int threshold;
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    public abstract static class PutField {
+
+        public PutField() {
+            throw new RuntimeException("Stub!");
+        }
+
+        public abstract void put(java.lang.String name, boolean val);
+
+        public abstract void put(java.lang.String name, byte val);
+
+        public abstract void put(java.lang.String name, char val);
+
+        public abstract void put(java.lang.String name, short val);
+
+        public abstract void put(java.lang.String name, int val);
+
+        public abstract void put(java.lang.String name, long val);
+
+        public abstract void put(java.lang.String name, float val);
+
+        public abstract void put(java.lang.String name, double val);
+
+        public abstract void put(java.lang.String name, java.lang.Object val);
+
+        @Deprecated
+        public abstract void write(java.io.ObjectOutput out) throws java.io.IOException;
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private class PutFieldImpl extends java.io.ObjectOutputStream.PutField {
+
+        PutFieldImpl(java.io.ObjectStreamClass desc) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, boolean val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, byte val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, char val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, short val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, int val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, float val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, long val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, double val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void put(java.lang.String name, java.lang.Object val) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void write(java.io.ObjectOutput out) throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        void writeFields() throws java.io.IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        private int getFieldOffset(java.lang.String name, java.lang.Class<?> type) {
+            throw new RuntimeException("Stub!");
+        }
+
+        private final java.io.ObjectStreamClass desc;
+
+        {
+            desc = null;
+        }
+
+        private final java.lang.Object[] objVals;
+
+        {
+            objVals = new java.lang.Object[0];
+        }
+
+        private final byte[] primVals;
+
+        {
+            primVals = new byte[0];
+        }
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private static class ReplaceTable {
+
+        ReplaceTable(int initialCapacity, float loadFactor) {
+            throw new RuntimeException("Stub!");
+        }
+
+        void assign(java.lang.Object obj, java.lang.Object rep) {
+            throw new RuntimeException("Stub!");
+        }
+
+        java.lang.Object lookup(java.lang.Object obj) {
+            throw new RuntimeException("Stub!");
+        }
+
+        void clear() {
+            throw new RuntimeException("Stub!");
+        }
+
+        int size() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private void grow() {
+            throw new RuntimeException("Stub!");
+        }
+
+        private final java.io.ObjectOutputStream.HandleTable htab;
+
+        {
+            htab = null;
+        }
+
+        private java.lang.Object[] reps;
+    }
+}