</postConstruct>
		<postConstruct name="put">
			<arg>"//AREA"</arg>
			<arg>"href"</arg>
		</postConstruct>
		<postConstruct name="put">
			<arg>"//FRAME"</arg>
			<arg>"src"</arg>
		</postConstruct>
		<postConstruct name="put">
			<arg>"//IFRAME"</arg>
			<arg>"src"</arg>
		</postConstruct>
		<postConstruct name="put">
			<arg>"//IMG"</arg>
			<arg>"src"</arg>
		</postConstruct>

    }
  }

  /**
   * Attempts to remove a single frame from a queue and send it. This prefers to write urgent pongs
   * before less urgent messages and close frames. For example, it's possible that a caller will
   * enqueue messages followed by pongs, but this sends pongs followed by messages. Pongs are always
   * written in the order they were enqueued.
   *

            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");

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

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>

import okhttp3.internal.ws.WebSocketProtocol.validateCloseCode
import okio.Buffer
import okio.BufferedSink
import okio.ByteString

/**
 * An [RFC 6455][rfc_6455]-compatible WebSocket frame writer.
 *
 * This class is not thread safe.
 *
 * [rfc_6455]: http://tools.ietf.org/html/rfc6455
 */
class WebSocketWriter(
  private val isClient: Boolean,
  val sink: BufferedSink,
  val random: Random,

    /** 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 = 3

    /** Window size in bytes. */
    const val INITIAL_WINDOW_SIZE = 4

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

    assertThat(webSocket.close(1000, null)).isFalse()
  }

  /**
   * There's no read timeout when reading the first byte of a new frame. But as soon as we start
   * reading a frame we enable the read timeout. In this test we have the server returning the first
   * byte of a frame but no more frames.
   */
  @Test
  fun readTimeoutAppliesWithinFrames() {
    webServer.dispatcher =
      object : Dispatcher() {

    close(ErrorCode.PROTOCOL_ERROR, ErrorCode.PROTOCOL_ERROR, e)
  }

  /**
   * Sends any initial frames and starts reading frames from the remote peer. This should be called
   * after [Builder.build] for all new connections.
   *
   * @param sendConnectionPreface true to send connection preface frames. This should always be true
   *     except for in tests that don't check for a connection preface.

 * limitations under the License.
 */
package okhttp3.internal.http2

import java.io.IOException

/**
 * Thrown when an HTTP/2 connection is shutdown (either explicitly or if the peer has sent a GOAWAY
 * frame) and an attempt is made to use the connection.
 */