std::string target_id;

std::string type;

std::string title;

std::string url;

std::shared_ptr<MainThreadHandle> worker;

bool attached;

public std::enable_shared_from_this<TargetAgent> {

public:

void Wire(UberDispatcher* dispatcher);

void createAndAttachIfNecessary(std::shared_ptr<MainThreadHandle> worker,

const std::string& title,

const std::string& url);

DispatchResponse setAutoAttach(bool auto_attach,

bool wait_for_debugger_on_start) override;

void listenWorker(std::weak_ptr<WorkerManager> worker_manager);

void reset();

static std::unordered_map<int, std::shared_ptr<MainThreadHandle>>

target_session_id_worker_map_;

bool isThisThread(MainThreadHandle* worker) { return worker == main_thread_; }

private:

int getNextTargetId();

int getNextSessionId();

void targetCreated(const std::string_view target_id,

const std::string_view type,

const std::string_view title,

const std::string_view url);

void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,

const std::string& target_id,

const std::string& type,

const std::string& title,

const std::string& url);

std::shared_ptr<Target::Frontend> frontend_;

std::weak_ptr<WorkerManager> worker_manager_;

static int next_session_id_;

int next_target_id_ = 1;

std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;

bool auto_attach_ = false;

// TODO(islandryu): If false, implement it so that each thread does not wait

// for the worker to execute.

bool wait_for_debugger_on_start_ = true;

std::vector<TargetInfo> targets_;

MainThreadHandle* main_thread_;