jdk-sandbox: comparison jdk/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java

equal deleted inserted replaced

-:cf334423502b
+:068494063b1b
 import sun.net.www.http.ChunkedOutputStream;
 import java.text.SimpleDateFormat;
 import java.util.TimeZone;
 import java.net.MalformedURLException;
 import java.nio.ByteBuffer;
-import java.nio.channels.ReadableByteChannel;
-import java.nio.channels.WritableByteChannel;
-import java.nio.channels.Selector;
-import java.nio.channels.SelectionKey;
-import java.nio.channels.SelectableChannel;
 import java.lang.reflect.*;
 /**
 * A class to represent an HTTP connection to a remote object.
 */
 * - get input, [read input]
 * Disallowed:
 * - get input, [read input,] get output, [write output]
 */
+@Override
 public synchronized OutputStream getOutputStream() throws IOException {
 try {
 if (!doOutput) {
 throw new ProtocolException("cannot write to a URLConnection"
 // remove old Cookie header before setting new one.
 requests.remove("Cookie");
 URI uri = ParseUtil.toURI(url);
 if (uri != null) {
-Map cookies = cookieHandler.get(uri, requests.getHeaders(EXCLUDE_HEADERS));
+Map<String, List<String>> cookies = cookieHandler.get(uri, requests.getHeaders(EXCLUDE_HEADERS));
 if (!cookies.isEmpty()) {
-Set s = cookies.entrySet();
+for (Map.Entry<String, List<String>> entry : cookies.entrySet()) {
-Iterator k_itr = s.iterator();
+String key = entry.getKey();
-while (k_itr.hasNext()) {
-Map.Entry entry = (Map.Entry)k_itr.next();
-String key = (String)entry.getKey();
 // ignore all entries that don't have "Cookie"
 // or "Cookie2" as keys
 if (!"Cookie".equalsIgnoreCase(key) &&
 !"Cookie2".equalsIgnoreCase(key)) {
 continue;
 }
-List l = (List)entry.getValue();
+List<String> l = entry.getValue();
 if (l != null && !l.isEmpty()) {
-Iterator v_itr = l.iterator();
 StringBuilder cookieValue = new StringBuilder();
-while (v_itr.hasNext()) {
+for (String value : l) {
-String value = (String)v_itr.next();
+cookieValue.append(value).append("; ");
-cookieValue.append(value).append(';');
 }
-// strip off the ending ;-sign
+// strip off the trailing '; '
 try {
-requests.add(key, cookieValue.substring(0, cookieValue.length() - 1));
+requests.add(key, cookieValue.substring(0, cookieValue.length() - 2));
 } catch (StringIndexOutOfBoundsException ignored) {
 // no-op
 }
 }
 }
 }
 } // end of getting cookies
 }
+@Override
+@SuppressWarnings("empty-statement")
 public synchronized InputStream getInputStream() throws IOException {
 if (!doInput) {
 throw new ProtocolException("Cannot read from URLConnection"
 + " if doInput=false (call setDoInput(true))");
 } catch (Exception ignored) {
 return rememberedException;
 }
 }
+@Override
 public InputStream getErrorStream() {
 if (connected && responseCode >= 400) {
 // Client Error 4xx and Server Error 5xx
 if (errorStream != null) {
 return errorStream;
 /**
 * Gets a header field by name. Returns null if not known.
 * @param name the name of the header field
 */
+@Override
 public String getHeaderField(String name) {
 try {
 getInputStream();
 } catch (IOException e) {}
 * the corresponding field values.
 *
 * @return a Map of header fields
 * @since 1.4
 */
+@Override
 public Map getHeaderFields() {
 try {
 getInputStream();
 } catch (IOException e) {}
 /**
 * Gets a header field by index. Returns null if not known.
 * @param n the index of the header field
 */
+@Override
 public String getHeaderField(int n) {
 try {
 getInputStream();
 } catch (IOException e) {}
 /**
 * Gets a header field by index. Returns null if not known.
 * @param n the index of the header field
 */
+@Override
 public String getHeaderFieldKey(int n) {
 try {
 getInputStream();
 } catch (IOException e) {}
 /**
 * Sets request property. If a property with the key already
 * exists, overwrite its value with the new value.
 * @param value the value to be set
 */
+@Override
 public void setRequestProperty(String key, String value) {
 if (connected)
 throw new IllegalStateException("Already connected");
 if (key == null)
 throw new NullPointerException ("key is null");
 *                  (e.g., "<code>accept</code>").
 * @param   value  the value associated with it.
 * @see #getRequestProperties(java.lang.String)
 * @since 1.4
 */
+@Override
 public void addRequestProperty(String key, String value) {
 if (connected)
 throw new IllegalStateException("Already connected");
 if (key == null)
 throw new NullPointerException ("key is null");
 void setAuthenticationProperty(String key, String value) {
 checkMessageHeader(key, value);
 requests.set(key, value);
 }
+@Override
 public String getRequestProperty (String key) {
 // don't return headers containing security sensitive information
 if (key != null) {
 for (int i=0; i < EXCLUDE_HEADERS.length; i++) {
 if (key.equalsIgnoreCase(EXCLUDE_HEADERS[i])) {
 *
 * @return  a Map of the general request properties for this connection.
 * @throws IllegalStateException if already connected
 * @since 1.4
 */
+@Override
 public Map getRequestProperties() {
 if (connected)
 throw new IllegalStateException("Already connected");
 // exclude headers containing security-sensitive info
 return requests.getHeaders(EXCLUDE_HEADERS);
 }
+@Override
 public void setConnectTimeout(int timeout) {
 if (timeout < 0)
 throw new IllegalArgumentException("timeouts can't be negative");
 connectTimeout = timeout;
 }
 *         value in milliseconds
 * @see java.net.URLConnection#setConnectTimeout(int)
 * @see java.net.URLConnection#connect()
 * @since 1.5
 */
+@Override
 public int getConnectTimeout() {
 return (connectTimeout < 0 ? 0 : connectTimeout);
 }
 /**
 *
 * @see java.net.URLConnectiongetReadTimeout()
 * @see java.io.InputStream#read()
 * @since 1.5
 */
+@Override
 public void setReadTimeout(int timeout) {
 if (timeout < 0)
 throw new IllegalArgumentException("timeouts can't be negative");
 readTimeout = timeout;
 }
 *
 * @see java.net.URLConnection#setReadTimeout(int)
 * @see java.io.InputStream#read()
 * @since 1.5
 */
+@Override
 public int getReadTimeout() {
 return readTimeout < 0 ? 0 : readTimeout;
 }
+@Override
 protected void finalize() {
 // this should do nothing.  The stream finalizer will close
 // the fd
 }
 * @param   readlimit   the maximum limit of bytes that can be read before
 *                      the mark position becomes invalid.
 * @see     java.io.FilterInputStream#in
 * @see     java.io.FilterInputStream#reset()
 */
+@Override
 public synchronized void mark(int readlimit) {
 super.mark(readlimit);
 if (cacheRequest != null) {
 marked = true;
 markCount = 0;
 * @exception  IOException  if the stream has not been marked or if the
 *               mark has been invalidated.
 * @see        java.io.FilterInputStream#in
 * @see        java.io.FilterInputStream#mark(int)
 */
+@Override
 public synchronized void reset() throws IOException {
 super.reset();
 if (cacheRequest != null) {
 marked = false;
 inCache += markCount;
 }
 }
+@Override
 public int read() throws IOException {
 try {
 byte[] b = new byte[1];
 int ret = read(b);
 return (ret == -1? ret : (b[0] & 0x00FF));
 }
 throw ioex;
 }
 }
+@Override
 public int read(byte[] b) throws IOException {
 return read(b, 0, b.length);
 }
+@Override
 public int read(byte[] b, int off, int len) throws IOException {
 try {
 int newLen = super.read(b, off, len);
 int nWrite;
 // write to cache
 }
 throw ioex;
 }
 }
+@Override
 public void close () throws IOException {
 try {
 if (outputStream != null) {
 if (read() != -1) {
 cacheRequest.abort();
 written = 0;
 closed = false;
 error = false;
 }
+@Override
 public void write (int b) throws IOException {
 checkError();
 written ++;
 if (expected != -1 && written > expected) {
 throw new IOException ("too many bytes written");
 }
 out.write (b);
 }
+@Override
 public void write (byte[] b) throws IOException {
 write (b, 0, b.length);
 }
+@Override
 public void write (byte[] b, int off, int len) throws IOException {
 checkError();
 written += len;
 if (expected != -1 && written > expected) {
 out.close ();
 */
 boolean writtenOK () {
 return closed && ! error;
 }
+@Override
 public void close () throws IOException {
 if (closed) {
 return;
 }
 closed = true;
 // ioex.printStackTrace();
 return null;
 }
 }
+@Override
 public int available() throws IOException {
 if (is == null) {
 return buffer.remaining();
 } else {
 return buffer.remaining()+is.available();
 byte[] b = new byte[1];
 int ret = read(b);
 return (ret == -1? ret : (b[0] & 0x00FF));
 }
+@Override
 public int read(byte[] b) throws IOException {
 return read(b, 0, b.length);
 }
+@Override
 public int read(byte[] b, int off, int len) throws IOException {
 int rem = buffer.remaining();
 if (rem > 0) {
 int ret = rem < len? rem : len;
 buffer.get(b, off, ret);
 return is.read(b, off, len);
 }
 }
 }
+@Override
 public void close() throws IOException {
 buffer = null;
 if (is != null) {
 is.close();
 }
 * HEAD method - i.e., stream not dead, but nothing to be read.
 */
 class EmptyInputStream extends InputStream {
+@Override
 public int available() {
 return 0;
 }
 public int read() {

changeset 74	068494063b1b
parent 2	90ce3da70b43
child 78	65353d0d0e31