Merge "Synchronize rootcanal periodic tasks to avoid a race with packet delivery."

    return true;

  }

  void Synchronize(const CriticalCallback& critical) {

    std::unique_lock<std::mutex> guard(synchronization_mutex_);

    critical();

  }

  AsyncTaskManager() = default;

  AsyncTaskManager(const AsyncTaskManager&) = delete;

  AsyncTaskManager& operator=(const AsyncTaskManager&) = delete;

      }

      if (run_it) {

        const std::lock_guard<std::mutex> lock(task_p->in_callback);

        callback();

        Synchronize(callback);

      }

      {

        std::unique_lock<std::mutex> guard(internal_mutex_);

  bool running_ = false;

  std::thread thread_;

  std::mutex internal_mutex_;

  std::mutex synchronization_mutex_;

  std::condition_variable internal_cond_var_;

  AsyncTaskId lastTaskId_ = kInvalidTaskId;

  return taskManager_p_->CancelAsyncTasksFromUser(user_id);

}

void AsyncManager::Synchronize(const CriticalCallback& critical_callback) {

  std::unique_lock<std::mutex> guard(synchronization_mutex_);

  critical_callback();

void AsyncManager::Synchronize(const CriticalCallback& critical) {

  taskManager_p_->Synchronize(critical);

}

}  // namespace rootcanal

  // destroying the other one

  std::unique_ptr<AsyncFdWatcher> fdWatcher_p_;

  std::unique_ptr<AsyncTaskManager> taskManager_p_;

  std::mutex synchronization_mutex_;

};

}  // namespace rootcanal

#endif  // TEST_VENDOR_LIB_ASYNC_MANAGER_H_