}

  /** Maximum length of an outbound data frame.  */
  fun maxOutboundDataLength(): Int = writer.maxDataLength()

  /** Count of frames sent or received.  */
  fun frameCount(): Int = frameCount

  fun sendFrame(): Http2Writer {
    outFrames.add(OutFrame(frameCount++, bytesOut.size, false))
    return writer
  }

  /**
   * Shortens the last frame from its original length to `length`. This will cause the peer to

  val showHeaders: Boolean by option("-i", "--include", help = "Include protocol headers in the output").flag()

  val showHttp2Frames: Boolean by option("--frames", help = "Log HTTP/2 frames to STDERR").flag()

  val referer: String? by option("-e", "--referer", help = "Referer URL")

  val verbose: Boolean by option("-v", "--verbose", help = "Makes $NAME verbose during the operation").flag()

      payload.writeByte('0'.code)
    }
    serverWriter.writeMessageFrame(OPCODE_BINARY, payload.snapshot())

    // Write directly to the unbuffered sink. This ensures it will become single frame.
    assertData("827e") // 'e' == 4-byte follow-up length.
    assertData(format("%04X", payload.completeSegmentByteCount()))
    assertData(payload.readByteString())
  }

  @Test fun serverMessageLengthLong() {

Blocking APIs may be inefficient because you hold a thread idle while waiting on the network. Threads are expensive because they have both a memory overhead and a context-switching overhead.

#### Framed protocols

    /** HTTP/2: The peer must not send a PUSH_PROMISE frame when this is 0. */
    const val ENABLE_PUSH = 2

    /** Sender's maximum number of concurrent streams. */
    const val MAX_CONCURRENT_STREAMS = 4

    /** HTTP/2: Size in bytes of the largest frame payload the sender will accept. */
    const val MAX_FRAME_SIZE = 5

      assertThat(event.responseBody).isEqualTo(body)
    }
    assertThat(event.t.javaClass).isEqualTo(cls)
    assertThat(event.t.message).isEqualTo(message)
  }

  /** Expose this recorder as a frame callback and shim in "ping" events.  */
  fun asFrameCallback() =
    object : WebSocketReader.FrameCallback {
      override fun onReadMessage(text: String) {
        events.add(Message(string = text))
      }

```
$ adb shell setprop log.tag.okhttp.Http2 DEBUG
$ adb shell setprop log.tag.okhttp.TaskRunner DEBUG
$ adb logcat '*:E' 'okhttp.Http2:D' 'okhttp.TaskRunner:D'
```

### HTTP/2 Frame Logging

This logs inbound (`<<`) and outbound (`>>`) frames for HTTP/2 connections.

```
[2020-01-01 00:00:00] >> CONNECTION 505249202a20485454502f322e300d0a0d0a534d0d0a0d0a
[2020-01-01 00:00:00] >> 0x00000000     6 SETTINGS

 *  * [onHeaders] (unless canceled)
 *  * [onData] (optional sequence of data frames)
 *
 * As a stream ID is scoped to a single HTTP/2 connection, implementations which target multiple
 * connections should expect repetition of stream IDs.
 *
 * Return true to request cancellation of a pushed stream.  Note that this does not guarantee
 * future frames won't arrive on the stream ID.
 */
interface PushObserver {
  /**

  /** Byte 0 reserved flag 3. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV3 = 16

  /** Byte 0 mask for the frame opcode. */
  internal const val B0_MASK_OPCODE = 15

  /** Flag in the opcode which indicates a control frame. */
  internal const val OPCODE_FLAG_CONTROL = 8

  /**
   * Byte 1 flag for whether the payload data is masked.
   *
   * If this flag is set, the next four

    tag: String,
  ) {
    val logger = Logger.getLogger(logger)
    if (configuredLoggers.add(logger)) {
      logger.useParentHandlers = false
      // log based on levels at startup to avoid logging each frame
      logger.level =
        when {
          Log.isLoggable(tag, Log.DEBUG) -> Level.FINE
          Log.isLoggable(tag, Log.INFO) -> Level.INFO
          else -> Level.WARNING
        }