// Write the first headers frame.
    writeMedium(frame, Http2.INITIAL_MAX_FRAME_SIZE)
    frame.writeByte(Http2.TYPE_HEADERS)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.write(headerBlock, Http2.INITIAL_MAX_FRAME_SIZE.toLong())

    // Write the continuation frame, specifying no more frames are expected.
    writeMedium(frame, headerBlock.size.toInt())

import okio.Timeout

/**
 * Reads HTTP/2 transport frames.
 *
 * This implementation assumes we do not send an increased [frame][Settings.getMaxFrameSize] to the
 * peer. Hence, we expect all frames to have a max length of [Http2.INITIAL_MAX_FRAME_SIZE].
 */
class Http2Reader(
  /** Creates a frame reader with max header table size of 4096. */
  private val source: BufferedSource,
  private val client: Boolean,
) : Closeable {

      reason: String,
    )
  }

  /**
   * Process the next protocol frame.
   *
   *  * If it is a control frame this will result in a single call to [FrameCallback].
   *  * If it is a message frame this will result in a single call to [FrameCallback.onReadMessage].
   *    If the message spans multiple frames, each interleaved control frame will result in a
   *    corresponding call to [FrameCallback].
   */

pkg runtime, method (*Frames) Next() (Frame, bool)
pkg runtime, type Frame struct
pkg runtime, type Frame struct, Entry uintptr
pkg runtime, type Frame struct, File string
pkg runtime, type Frame struct, Func *Func
pkg runtime, type Frame struct, Function string
pkg runtime, type Frame struct, Line int
pkg runtime, type Frame struct, PC uintptr
pkg runtime, type Frames struct

The frame size <code>$24-8</code> states that the function has a 24-byte frame
and is called with 8 bytes of argument, which live on the caller's frame.
If <code>NOSPLIT</code> is not specified for the <code>TEXT</code>,
the argument size must be provided.
For assembly functions with Go prototypes, <code>go</code> <code>vet</code> will check that the
argument size is correct.
</p>

<p>

  /** True if we've enqueued a close frame. No further message frames will be enqueued. */
  private var enqueuedClose = false

  /** The close code from the peer, or -1 if this web socket has not yet read a close frame. */
  private var receivedCloseCode = -1

  /** The close reason from the peer, or null if this web socket has not yet read a close frame. */
  private var receivedCloseReason: String? = null

	"encoding/binary"
	"fmt"
	"hash/crc32"
	"net/http"
	"strconv"
	"sync/atomic"
	"time"
)

// A message is in the format specified in
// https://docs.aws.amazon.com/AmazonS3/latest/API/images/s3select-frame-diagram-frame-overview.png
// hence the calculation is made accordingly.
func totalByteLength(headerLength, payloadLength int) int {
	return 4 + 4 + 4 + headerLength + payloadLength + 4
}

        outFinished = errorCode == null
      }
      if (!sink.finished) {
        // We have 0 or more frames of data, and 0 or more frames of trailers. We need to send at
        // least one frame with the END_STREAM flag set. That must be the last frame, and the
        // trailers must be sent after all of the data.
        val hasData = sendBuffer.size > 0L
        val hasTrailers = trailers != null
        when {
          hasTrailers -> {

    assertThat(client.canceled).isFalse()

    taskFaker.advanceUntil(ns(RealWebSocket.CANCEL_AFTER_CLOSE_MILLIS))
    assertThat(client.canceled).isTrue()

    client.processNextFrame() // This won't get a frame, but it will get a closed pipe.
    client.listener.assertFailure(IOException::class.java, "canceled")
    taskFaker.runTasks()
  }

  @Test
  fun clientCloseCancelsConnectionAfterCustomTimeout() {

            Map<String, String> childUrlRuleMap = newHashMap();
            childUrlRuleMap.put("//A", "href");
            childUrlRuleMap.put("//AREA", "href");
            childUrlRuleMap.put("//FRAME", "src");
            childUrlRuleMap.put("//IFRAME", "src");
            childUrlRuleMap.put("//IMG", "src");
            childUrlRuleMap.put("//LINK", "href");
            childUrlRuleMap.put("//SCRIPT", "src");