adb: fdevent: move TerminateLoop to fdevent_context. am: ebaa348d

    Interrupt();

}

void fdevent_context::TerminateLoop() {

    terminate_loop_ = true;

    Interrupt();

}

void fdevent_context::FlushRunQueue() {

    // We need to be careful around reentrancy here, since a function we call can queue up another

    // function.

    // trigger repeatedly every |timeout| ms.

    virtual void SetTimeout(fdevent* fde, std::optional<std::chrono::milliseconds> timeout) = 0;

    // Loop forever, handling events.

    // Implementations should call FlushRunQueue on every iteration.

    // Loop until TerminateLoop is called, handling events.

    // Implementations should call FlushRunQueue on every iteration, and check the value of

    // terminate_loop_ to determine whether to stop.

    virtual void Loop() = 0;

    // Assert that the caller is either running on the context's main thread, or that there is no

    void Run(std::function<void()> fn);

    // Test-only functionality:

    virtual void TerminateLoop() = 0;

    void TerminateLoop();

    virtual size_t InstalledCount() = 0;

  protected:

    void FlushRunQueue() EXCLUDES(run_queue_mutex_);

    std::optional<uint64_t> main_thread_id_ = std::nullopt;

    std::atomic<bool> terminate_loop_ = false;

  private:

    std::mutex run_queue_mutex_;

    main_thread_id_.reset();

}

void fdevent_context_poll::TerminateLoop() {

    terminate_loop_ = true;

    Interrupt();

}

size_t fdevent_context_poll::InstalledCount() {

    // We always have an installed fde for interrupt.

    return poll_node_map_.size() - 1;

    virtual void Loop() final;

    virtual void TerminateLoop() final;

    virtual size_t InstalledCount() final;

  protected:

    unique_fd interrupt_fd_;

    fdevent* interrupt_fde_ = nullptr;

    std::atomic<bool> terminate_loop_ = false;

};