src/java.base/share/classes/java/io/BufferedInputStream.java

rev 54801 : [mq]: 8223593-Refactor-code-for-reallocating-storage

*** 1,7 ****
  /*
!  * Copyright (c) 1994, 2016, 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
--- 1,7 ----
  /*
!  * 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
*** 24,33 ****
--- 24,34 ----
   */
  
  package java.io;
  
  import jdk.internal.misc.Unsafe;
+ import jdk.internal.util.ArraysSupport;
  
  /**
   * A <code>BufferedInputStream</code> adds
   * functionality to another input stream-namely,
   * the ability to buffer the input and to
*** 52,69 ****
  class BufferedInputStream extends FilterInputStream {
  
      private static int DEFAULT_BUFFER_SIZE = 8192;
  
      /**
-      * The maximum size of array to allocate.
-      * Some VMs reserve some header words in an array.
-      * Attempts to allocate larger arrays may result in
-      * OutOfMemoryError: Requested array size exceeds VM limit
-      */
-     private static int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;
- 
-     /**
       * As this class is used early during bootstrap, it's motivated to use
       * Unsafe.compareAndSetObject instead of AtomicReferenceFieldUpdater
       * (or VarHandles) to reduce dependencies and improve startup time.
       */
      private static final Unsafe U = Unsafe.getUnsafe();
--- 53,62 ----
*** 218,241 ****
       */
      private void fill() throws IOException {
          byte[] buffer = getBufIfOpen();
          if (markpos < 0)
              pos = 0;            /* no mark: throw away the buffer */
!         else if (pos >= buffer.length)  /* no room left in buffer */
              if (markpos > 0) {  /* can throw away early part of the buffer */
                  int sz = pos - markpos;
                  System.arraycopy(buffer, markpos, buffer, 0, sz);
                  pos = sz;
                  markpos = 0;
              } else if (buffer.length >= marklimit) {
                  markpos = -1;   /* buffer got too big, invalidate mark */
                  pos = 0;        /* drop buffer contents */
-             } else if (buffer.length >= MAX_BUFFER_SIZE) {
-                 throw new OutOfMemoryError("Required array size too large");
              } else {            /* grow buffer */
!                 int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
!                         pos * 2 : MAX_BUFFER_SIZE;
                  if (nsz > marklimit)
                      nsz = marklimit;
                  byte[] nbuf = new byte[nsz];
                  System.arraycopy(buffer, 0, nbuf, 0, pos);
                  if (!U.compareAndSetReference(this, BUF_OFFSET, buffer, nbuf)) {
--- 211,231 ----
       */
      private void fill() throws IOException {
          byte[] buffer = getBufIfOpen();
          if (markpos < 0)
              pos = 0;            /* no mark: throw away the buffer */
!         else if (pos >= buffer.length) { /* no room left in buffer */
              if (markpos > 0) {  /* can throw away early part of the buffer */
                  int sz = pos - markpos;
                  System.arraycopy(buffer, markpos, buffer, 0, sz);
                  pos = sz;
                  markpos = 0;
              } else if (buffer.length >= marklimit) {
                  markpos = -1;   /* buffer got too big, invalidate mark */
                  pos = 0;        /* drop buffer contents */
              } else {            /* grow buffer */
!                 int nsz = ArraysSupport.newCapacity(pos, 1, pos);
                  if (nsz > marklimit)
                      nsz = marklimit;
                  byte[] nbuf = new byte[nsz];
                  System.arraycopy(buffer, 0, nbuf, 0, pos);
                  if (!U.compareAndSetReference(this, BUF_OFFSET, buffer, nbuf)) {
*** 246,255 ****
--- 236,246 ----
                      // assert buf == null;
                      throw new IOException("Stream closed");
                  }
                  buffer = nbuf;
              }
+         }
          count = pos;
          int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
          if (n > 0)
              count = n + pos;
      }