native CountDownLatch

class CountDownLatch {
public:
    enum {
        eSyncTransaction = 1 << 0,
        eSyncInputWindows = 1 << 1,
    };
    explicit CountDownLatch(uint32_t flags) : mFlags(flags) {}

    // True if there is no waiting condition after count down.
    bool countDown(uint32_t flag) {
        std::unique_lock<std::mutex> lock(mMutex);
        if (mFlags == 0) {
            return true;
        }
        mFlags &= ~flag;
        if (mFlags == 0) {
            mCountDownComplete.notify_all();
            return true;
        }
        return false;
    }

    // Return true if triggered.
    bool wait_until(const std::chrono::nanoseconds& timeout) const {
        std::unique_lock<std::mutex> lock(mMutex);
        const auto untilTime = std::chrono::system_clock::now() + timeout;
        while (mFlags != 0) {
            // Conditional variables can be woken up sporadically, so we check count
            // to verify the wakeup was triggered by |countDown|.
            if (std::cv_status::timeout == mCountDownComplete.wait_until(lock, untilTime)) {
                return false;
            }
        }
        return true;
    }

private:
    uint32_t mFlags;
    mutable std::condition_variable mCountDownComplete;
    mutable std::mutex mMutex;
};