jdk-sandbox: comparison src/java.base/share/classes/sun/net/www/MeteredStream.java

equal deleted inserted replaced

-:e89c7aaf2906
+:8595871a5446
 /*
-* Copyright (c) 1994, 2017, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1994, 2019, 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
 * questions.
 */
 package sun.net.www;
-import java.net.URL;
-import java.util.*;
 import java.io.*;
+import java.util.concurrent.locks.ReentrantLock;
 import sun.net.ProgressSource;
 import sun.net.www.http.ChunkedInputStream;
 public class MeteredStream extends FilterInputStream {
 protected long expected;
 protected long count = 0;
 protected long markedCount = 0;
 protected int markLimit = -1;
 protected ProgressSource pi;
+protected final ReentrantLock readLock = new ReentrantLock();
 public MeteredStream(InputStream is, ProgressSource pi, long expected)
 {
 super(is);
 if (pi != null) {
 pi.updateProgress(0, expected);
 }
 }
-private final void justRead(long n) throws IOException   {
+private final  void justRead(long n) throws IOException   {
+assert readLock.isHeldByCurrentThread();
 if (n == -1) {
 /*
 * don't close automatically when mark is set and is valid;
 * cannot reset() after close()
 /**
 * Returns true if the mark is valid, false otherwise
 */
 private boolean isMarked() {
+assert readLock.isHeldByCurrentThread();
 if (markLimit < 0) {
 return false;
 }
 // mark still holds
 return true;
 }
-public synchronized int read() throws java.io.IOException {
+public int read() throws java.io.IOException {
-if (closed) {
+if (closed) return -1;
-return -1;
+readLock.lock();
-}
+try {
-int c = in.read();
+if (closed) return -1;
-if (c != -1) {
+int c = in.read();
-justRead(1);
+if (c != -1) {
-} else {
+justRead(1);
-justRead(c);
+} else {
-}
+justRead(c);
-return c;
+}
-}
+return c;
+} finally {
-public synchronized int read(byte b[], int off, int len)
+readLock.unlock();
+}
+}
+public int read(byte b[], int off, int len)
 throws java.io.IOException {
-if (closed) {
+if (closed) return -1;
-return -1;
+readLock.lock();
-}
+try {
-int n = in.read(b, off, len);
+if (closed) return -1;
-justRead(n);
-return n;
+int n = in.read(b, off, len);
-}
+justRead(n);
+return n;
-public synchronized long skip(long n) throws IOException {
+} finally {
+readLock.unlock();
-// REMIND: what does skip do on EOF????
+}
-if (closed) {
+}
-return 0;
-}
+public long skip(long n) throws IOException {
-if (in instanceof ChunkedInputStream) {
+if (closed) return 0;
-n = in.skip(n);
+readLock.lock();
-}
+try {
-else {
+// REMIND: what does skip do on EOF????
-// just skip min(n, num_bytes_left)
+if (closed) return 0;
-long min = (n > expected - count) ? expected - count: n;
-n = in.skip(min);
+if (in instanceof ChunkedInputStream) {
-}
+n = in.skip(n);
-justRead(n);
+} else {
-return n;
+// just skip min(n, num_bytes_left)
+long min = (n > expected - count) ? expected - count : n;
+n = in.skip(min);
+}
+justRead(n);
+return n;
+} finally {
+readLock.unlock();
+}
 }
 public void close() throws IOException {
-if (closed) {
+if (closed) return;
-return;
+readLock.lock();
-}
+try {
-if (pi != null)
+if (closed) return;
-pi.finishTracking();
+if (pi != null)
+pi.finishTracking();
-closed = true;
-in.close();
+closed = true;
-}
+in.close();
+} finally {
-public synchronized int available() throws IOException {
+readLock.unlock();
-return closed ? 0: in.available();
+}
 }
-public synchronized void mark(int readLimit) {
+public int available() throws IOException {
-if (closed) {
+if (closed) return 0;
-return;
+readLock.lock();
-}
+try {
-super.mark(readLimit);
+return closed ? 0 : in.available();
+} finally {
-/*
+readLock.unlock();
-* mark the count to restore upon reset
+}
-*/
+}
-markedCount = count;
-markLimit = readLimit;
+public void mark(int readLimit) {
-}
+if (closed) return;
+readLock.lock();
-public synchronized void reset() throws IOException {
+try {
-if (closed) {
+if (closed) return;
-return;
+super.mark(readLimit);
-}
+/*
-if (!isMarked()) {
+* mark the count to restore upon reset
-throw new IOException ("Resetting to an invalid mark");
+*/
-}
+markedCount = count;
+markLimit = readLimit;
-count = markedCount;
+} finally {
-super.reset();
+readLock.unlock();
+}
+}
+public void reset() throws IOException {
+if (closed) return;
+readLock.lock();
+try {
+if (closed) return;
+if (!isMarked()) {
+throw new IOException("Resetting to an invalid mark");
+}
+count = markedCount;
+super.reset();
+} finally {
+readLock.unlock();
+}
 }
 public boolean markSupported() {
-if (closed) {
+if (closed) return false;
-return false;
+readLock.lock();
-}
+try {
-return super.markSupported();
+if (closed) return false;
+return super.markSupported();
+} finally {
+readLock.unlock();
+}
 }
 @SuppressWarnings("deprecation")
 protected void finalize() throws Throwable {
 try {

branch	JDK-8229867-branch
changeset 57968	8595871a5446
parent 47216	71c04702a3d5