offer(e); // never need to block
  }

  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public @Nullable E poll() {
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      return q.poll();
    } finally {
      monitor.leave();
    }
  }

  @CanIgnoreReturnValue // pushed down from class to method
  @Override

            blocks:
              - type: "section"
                text:
                  type: "mrkdwn",

 * 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 {
  /**
   * Describes the request that the server intends to push a response for.
   *
   * @param streamId server-initiated stream ID: an even number.

- [ ] Check ["Allow edit from maintainers" option](https://help.github.com/articles/allowing-changes-to-a-pull-request-branch-created-from-a-fork/) in pull request so that additional changes can be pushed by Gradle team.
- [ ] Provide integration tests (under `<subproject>/src/integTest`) to verify changes from a user perspective.
- [ ] Provide unit tests (under `<subproject>/src/test`) to verify logic.

    }

    public Logger logger;

    // this one "evolves" as process progresses (instance is immutable but instances are replaced)
    public ProtoSession protoSession;
    // here we track which user properties we pushed to Java System Properties (internal only)
    public Set<String> pushedUserProperties;

    public ILoggerFactory loggerFactory;
    public Slf4jConfiguration slf4jConfiguration;

### Threads

#### Application's calling thread

The application-layer must block on writing I/O. We can't return from a write until we've pushed its bytes onto the socket. Otherwise, if the write fails we are unable to deliver its IOException to the application. We would have told the application layer that the write succeeded, but it didn't!

     * pushed stream to this response.
     */
    public fun addPush(promise: PushPromise): Builder =
      apply {
        this.pushPromises_ += promise
      }

    /**
     * When [protocols][MockWebServer.protocols] include [HTTP_2][okhttp3.Protocol], this pushes
     * [settings] before writing the response.
     */

   */
  double stableIntervalMicros;

  /**
   * The time when the next request (no matter its size) will be granted. After granting a request,
   * this is pushed further in the future. Large requests push this further than small requests.
   */
  private long nextFreeTicketMicros = 0L; // could be either in the past or future

  private SmoothRateLimiter(SleepingStopwatch stopwatch) {

     * when {@link LookupContext#pushedUserProperties} is null will push user properties IF key does not already
     * exist among Java System Properties, and collects all they key it pushes. Second invocation happens AFTER
     * {@link PropertyContributor} SPI invocation, and "refreshes" already pushed user properties by re-writing them
     * as SPI may have modified them.
     */

  private val writerQueue = taskRunner.newQueue()

  /** Ensures push promise callbacks events are sent in order per stream. */
  private val pushQueue = taskRunner.newQueue()

  /** Notifies the listener of settings changes. */
  private val settingsListenerQueue = taskRunner.newQueue()

  /** User code to run in response to push promise events. */
  private val pushObserver: PushObserver = builder.pushObserver