code: static private WsByteBuffer[] putByteArrayKnownOverflow(WsByteBuffer[] inBuffers, byte[] value, BNFHeadersImpl bnfObj) {
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "Known buffer overflow in put.");
          }
  
          WsByteBuffer[] buffers = inBuffers;
          boolean bDone = false;
          int remaining = value.length;
          int offset = 0; // current offset into the value
          WsByteBuffer buffer = buffers[buffers.length - 1];
          int avail = buffer.capacity() - buffer.position();
  
          while (!bDone) {
              // if the available space is enough for the rest of the data,
              // add it and we're done
              if (remaining <= avail) {
                  buffer.put(value, offset, remaining);
                  bDone = true;
              }
              // if it's not, then we need to put what we can and then
              // expand the buffer[]
  
              else {
                  buffer.put(value, offset, avail);
                  buffer.flip();
  
                  offset += avail;
                  remaining -= avail;
  
                  // allocate a new buffer and expand the array
                  buffer = bnfObj.allocateBuffer(bnfObj.getOutgoingBufferSize());
                  buffers = WsByteBufferUtils.expandBufferArray(buffers, buffer);
                  avail = buffer.capacity();
              }
          }
          return buffers;
      }
docs: Given a wsbb[], we're adding a byte[] value to the last buffer. If
  that buffer fills up, then we will allocate a new one, expand the
  wsbb[] and keep going until the entire byte[] is added.
  <p>
  Returns the new wsbb[] (expanded if needed)
  
  @param inBuffers
  @param value
  @param bnfObj
  @return WsByteBuffer[]