*  Fix: Don't lose HTTP/2 flow control bytes when incoming data races with a stream close. If this
    happened enough then eventually the connection would stall.

 *  Fix: Acknowledge and apply inbound HTTP/2 settings atomically. Previously we had a race where we
    could use new flow control capacity before acknowledging it, causing strict HTTP/2 servers to
    fail the call.

        this.sink.finished = true
        condition.signalAll() // Because doReadTimeout() may have changed.
      }
    }

    // Only DATA frames are subject to flow-control. Transmit the HEADER frame if the connection
    // flow-control window is fully depleted.
    if (!flushHeaders) {
      this.withLock {
        flushHeaders = (connection.writeBytesTotal >= connection.writeBytesMaximum)
      }
    }

  /** Settings we communicate to the peer. */
  val okHttpSettings =
    Settings().apply {
      // Flow control was designed more for servers, or proxies than edge clients. If we are a client,
      // set the flow control window to 16MiB.  This avoids thrashing window updates every 64KiB, yet
      // small enough to avoid blowing up the heap.
      if (builder.client) {

    // transmitted until the flow-control window is updated from the first request.
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    assertThat(response2.code).isEqualTo(200)

    // Close the response body. This should discard the buffered data and update the connection
    // flow-control window.
    response1.close()

      result +=
        when {
          c.isSurrogate() -> {
            val low = (if (i + 1 < limit) this[i + 1] else '\u0000')
            if (c.isLowSurrogate() || !low.isLowSurrogate()) {
              '?'.code
            } else {
              i++
              0x010000 + (c.code and 0x03ff shl 10 or (low.code and 0x03ff))
            }
          }

          else -> c.code
        }

 * by holding a lock on the connection.
 */
class RealConnection(
  val taskRunner: TaskRunner,
  val connectionPool: RealConnectionPool,
  override val route: Route,
  /** The low-level TCP socket. */
  private var rawSocket: Socket?,
  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */

    security and performance.

 *  New: `ConnectionListener` publishes events for connects, disconnects, and use of pooled
    connections.

 *  Fix: Immediately update the connection's flow control window instead of waiting for the
    receiving stream to process it.

    This change may increase OkHttp's memory use for applications that make many concurrent HTTP

    assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
  }

  @Tag("Slow")
  @Test
  fun successfulExpectContinuePermitsConnectionReuseWithHttp2() {
    enableProtocol(Protocol.HTTP_2)
    successfulExpectContinuePermitsConnectionReuse()
  }

  @Tag("Slow")
  @Test
  fun unsuccessfulExpectContinuePreventsConnectionReuse() {
    server.enqueue(MockResponse())

  /** True if this connect was canceled; typically because it lost a race. */
  @Volatile private var canceled = false

  // These properties are initialized by connect() and never reassigned.

  /** The low-level TCP socket. */
  private var rawSocket: Socket? = null

  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */

    }

    if (requestMethod != "GET") {
      // Don't cache non-GET responses. We're technically allowed to cache HEAD requests and some
      // POST requests, but the complexity of doing so is high and the benefit is low.
      return null
    }

    if (response.hasVaryAll()) {
      return null
    }

    val entry = Entry(response)
    var editor: DiskLruCache.Editor? = null
    try {