If there's no `gzip` in the header, it will not try to decompress the body.

That way, the same route class can handle gzip compressed or uncompressed requests.

{* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *}

### Create a custom `GzipRoute` class { #create-a-custom-gziproute-class }

  /**
   * Invoked as soon as a call causes a connection to be started.
   */
  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) {}

  /**
   * Invoked as soon as a connection is successfully established.
   */

  }

  override fun updateRouteDatabaseAfterSuccess(route: Route) {
    call.client.routeDatabase.connected(route)
  }

  override fun connectStart(route: Route) {
    eventListener.connectStart(call, route.socketAddress, route.proxy)
    poolConnectionListener.connectStart(route, call)
  }

  override fun connectFailed(
    route: Route,
    protocol: Protocol?,
    e: IOException,
  ) {

    try {
      user.connectStart(route)

      connectSocket()
      success = true
      return ConnectResult(plan = this)
    } catch (e: IOException) {
      // If we used the ProxySelector, and got a IOException during connect, report the failure.
      if (route.address.proxy == null && route.proxy.type() != Proxy.Type.DIRECT) {
        route.address.proxySelector.connectFailed(

import java.util.concurrent.ThreadLocalRandom
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater
import okhttp3.Address
import okhttp3.ConnectionPool
import okhttp3.Route
import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Task
import okhttp3.internal.concurrent.TaskQueue
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.concurrent.assertLockHeld

  }

  /** Returns a plan for the first attempt at [route]. This throws if no plan is possible. */
  @Throws(IOException::class)
  internal fun planConnectToRoute(
    route: Route,
    routes: List<Route>? = null,
  ): ConnectPlan {
    if (route.address.sslSocketFactory == null) {
      if (ConnectionSpec.CLEARTEXT !in route.address.connectionSpecs) {

  }

  private fun assertRoute(
    route: Route,
    address: Address,
    proxy: Proxy,
    socketAddress: InetAddress,
    socketPort: Int,
  ) {
    assertThat(route.address).isEqualTo(address)
    assertThat(route.proxy).isEqualTo(proxy)
    assertThat(route.socketAddress.address).isEqualTo(socketAddress)
    assertThat(route.socketAddress.port).isEqualTo(socketPort)
  }

    }
  }

  override fun protocol(): Protocol = protocol

  override fun toString(): String =
    "Connection{${route.address.url.host}:${route.address.url.port}," +
      " proxy=${route.proxy}" +
      " hostAddress=${route.socketAddress}" +
      " cipherSuite=${handshake?.cipherSuite ?: "none"}" +
      " protocol=$protocol}"

  companion object {

    override val timestampNs: Long,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectFailed(
    override val timestampNs: Long,
    val route: Route,
    val call: Call,
    val exception: IOException,
  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(

    }
  }

  override fun connectStart(
    route: Route,
    call: Call,
  ) = logEvent(ConnectionEvent.ConnectStart(System.nanoTime(), route, call))

  override fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) = logEvent(
    ConnectionEvent.ConnectFailed(System.nanoTime(), route, call, failure),
  )

  override fun connectEnd(