Remove the "default buffer size" warnings.

Everyone seems to agree these have outlived their usefulness.

Change-Id: Ia2a53ffa1f9498333b4b2d51d5c1db488b89abaf
diff --git a/libcore/luni/src/main/java/java/io/BufferedInputStream.java b/libcore/luni/src/main/java/java/io/BufferedInputStream.java
index 22379dd..1ecae30 100644
--- a/libcore/luni/src/main/java/java/io/BufferedInputStream.java
+++ b/libcore/luni/src/main/java/java/io/BufferedInputStream.java
@@ -67,43 +67,22 @@
     protected int pos;
 
     /**
-     * Constructs a new {@code BufferedInputStream} on the {@link InputStream}
-     * {@code in}. The default buffer size (8 KB) is allocated and all reads
-     * can now be filtered through this stream.
+     * Constructs a new {@code BufferedInputStream}, providing {@code in} with a buffer
+     * of 8192 bytes.
      *
-     * @param in
-     *            the InputStream the buffer reads from.
+     * @param in the {@code InputStream} the buffer reads from.
      */
     public BufferedInputStream(InputStream in) {
-        super(in);
-        buf = new byte[8192];
-
-        // BEGIN android-added
-        /*
-         * For Android, we want to discourage the use of this constructor (with
-         * its arguably too-large default), so we note its use in the log. We
-         * don't disable it, nor do we alter the default, however, because we
-         * still aim to behave compatibly, and the default value, though not
-         * documented, is established by convention.
-         */
-        Logger.global.info(
-                "Default buffer size used in BufferedInputStream " +
-                "constructor. It would be " +
-                "better to be explicit if an 8k buffer is required.");
-        // END android-added
+        this(in, 8192);
     }
 
     /**
-     * Constructs a new {@code BufferedInputStream} on the {@link InputStream}
-     * {@code in}. The buffer size is specified by the parameter {@code size}
-     * and all reads are now filtered through this stream.
+     * Constructs a new {@code BufferedInputStream}, providing {@code in} with {@code size} bytes
+     * of buffer.
      *
-     * @param in
-     *            the input stream the buffer reads from.
-     * @param size
-     *            the size of buffer to allocate.
-     * @throws IllegalArgumentException
-     *             if {@code size < 0}.
+     * @param in the {@code InputStream} the buffer reads from.
+     * @param size the size of buffer in bytes.
+     * @throws IllegalArgumentException if {@code size <= 0}.
      */
     public BufferedInputStream(InputStream in, int size) {
         super(in);
diff --git a/libcore/luni/src/main/java/java/io/BufferedOutputStream.java b/libcore/luni/src/main/java/java/io/BufferedOutputStream.java
index d61e522..d255e27 100644
--- a/libcore/luni/src/main/java/java/io/BufferedOutputStream.java
+++ b/libcore/luni/src/main/java/java/io/BufferedOutputStream.java
@@ -51,42 +51,22 @@
     protected int count;
 
     /**
-     * Constructs a new {@code BufferedOutputStream} on the {@link OutputStream}
-     * {@code out}. The buffer size is set to the default value of 8 KB.
+     * Constructs a new {@code BufferedOutputStream}, providing {@code out} with a buffer
+     * of 8192 bytes.
      *
-     * @param out
-     *            the {@code OutputStream} for which write operations are
-     *            buffered.
+     * @param out the {@code OutputStream} the buffer writes to.
      */
     public BufferedOutputStream(OutputStream out) {
-        super(out);
-        buf = new byte[8192];
-
-        // BEGIN android-added
-        /*
-         * For Android, we want to discourage the use of this constructor (with
-         * its arguably too-large default), so we note its use in the log. We
-         * don't disable it, nor do we alter the default, however, because we
-         * still aim to behave compatibly, and the default value, though not
-         * documented, is established by convention.
-         */
-        Logger.global.info(
-                "Default buffer size used in BufferedOutputStream " +
-                "constructor. It would be " +
-                "better to be explicit if an 8k buffer is required.");
-        // END android-added
+        this(out, 8192);
     }
 
     /**
-     * Constructs a new {@code BufferedOutputStream} on the {@link OutputStream}
-     * {@code out}. The buffer size is set to {@code size}.
+     * Constructs a new {@code BufferedOutputStream}, providing {@code out} with {@code size} bytes
+     * of buffer.
      *
-     * @param out
-     *            the output stream for which write operations are buffered.
-     * @param size
-     *            the size of the buffer in bytes.
-     * @throws IllegalArgumentException
-     *             if {@code size <= 0}.
+     * @param out the {@code OutputStream} the buffer writes to.
+     * @param size the size of buffer in bytes.
+     * @throws IllegalArgumentException if {@code size <= 0}.
      */
     public BufferedOutputStream(OutputStream out, int size) {
         super(out);
diff --git a/libcore/luni/src/main/java/java/io/BufferedReader.java b/libcore/luni/src/main/java/java/io/BufferedReader.java
index 353f17c..356c4d7 100644
--- a/libcore/luni/src/main/java/java/io/BufferedReader.java
+++ b/libcore/luni/src/main/java/java/io/BufferedReader.java
@@ -75,43 +75,22 @@
     private int markLimit = -1;
 
     /**
-     * Constructs a new BufferedReader on the Reader {@code in}. The
-     * buffer gets the default size (8 KB).
-     * 
-     * @param in
-     *            the Reader that is buffered.
+     * Constructs a new {@code BufferedReader}, providing {@code in} with a buffer
+     * of 8192 characters.
+     *
+     * @param in the {@code Reader} the buffer reads from.
      */
     public BufferedReader(Reader in) {
-        super(in);
-        this.in = in;
-        buf = new char[8192];
-
-        // BEGIN android-only
-        /*
-         * For Android, we want to discourage the use of this
-         * constructor (with its arguably too-large default), so we
-         * note its use in the log. We don't disable it, nor do we
-         * alter the default, however, because we still aim to behave
-         * compatibly, and the default value, though not documented,
-         * is established by convention.
-         */
-        Logger.global.info(
-                "Default buffer size used in BufferedReader " +
-                "constructor. It would be " +
-                "better to be explicit if an 8k-char buffer is required.");
-        // END android-only
+        this(in, 8192);
     }
 
     /**
-     * Constructs a new BufferedReader on the Reader {@code in}. The buffer
-     * size is specified by the parameter {@code size}.
-     * 
-     * @param in
-     *            the Reader that is buffered.
-     * @param size
-     *            the size of the buffer to allocate.
-     * @throws IllegalArgumentException
-     *             if {@code size <= 0}.
+     * Constructs a new {@code BufferedReader}, providing {@code in} with {@code size} characters
+     * of buffer.
+     *
+     * @param in the {@code InputStream} the buffer reads from.
+     * @param size the size of buffer in characters.
+     * @throws IllegalArgumentException if {@code size <= 0}.
      */
     public BufferedReader(Reader in, int size) {
         super(in);
diff --git a/libcore/luni/src/main/java/java/io/BufferedWriter.java b/libcore/luni/src/main/java/java/io/BufferedWriter.java
index 39b20ba..1da93f8 100644
--- a/libcore/luni/src/main/java/java/io/BufferedWriter.java
+++ b/libcore/luni/src/main/java/java/io/BufferedWriter.java
@@ -55,44 +55,22 @@
             .doPrivileged(new PriviAction<String>("line.separator")); //$NON-NLS-1$
 
     /**
-     * Constructs a new {@code BufferedWriter} with {@code out} as the writer
-     * for which to buffer write operations. The buffer size is set to the
-     * default value of 8 KB.
+     * Constructs a new {@code BufferedWriter}, providing {@code out} with a buffer
+     * of 8192 bytes.
      *
-     * @param out
-     *            the writer for which character writing is buffered.
+     * @param out the {@code Writer} the buffer writes to.
      */
     public BufferedWriter(Writer out) {
-        super(out);
-        this.out = out;
-        buf = new char[8192];
-
-        // BEGIN android-added
-        /*
-         * For Android, we want to discourage the use of this constructor (with
-         * its arguably too-large default), so we note its use in the log. We
-         * don't disable it, nor do we alter the default, however, because we
-         * still aim to behave compatibly, and the default value, though not
-         * documented, is established by convention.
-         */
-        Logger.global.info(
-                "Default buffer size used in BufferedWriter " +
-                "constructor. It would be " +
-                "better to be explicit if an 8k-char buffer is required.");
-        // END android-added
+        this(out, 8192);
     }
 
     /**
-     * Constructs a new {@code BufferedWriter} with {@code out} as the writer
-     * for which to buffer write operations. The buffer size is set to {@code
-     * size}.
+     * Constructs a new {@code BufferedWriter}, providing {@code out} with {@code size} bytes
+     * of buffer.
      *
-     * @param out
-     *            the writer for which character writing is buffered.
-     * @param size
-     *            the size of the buffer in bytes.
-     * @throws IllegalArgumentException
-     *             if {@code size <= 0}.
+     * @param out the {@code OutputStream} the buffer writes to.
+     * @param size the size of buffer in bytes.
+     * @throws IllegalArgumentException if {@code size <= 0}.
      */
     public BufferedWriter(Writer out, int size) {
         super(out);