Merge "Avoid waiting indefinitely for BT stack cleanup. If stack cleanup takes...

#include "internal_include/stack_config.h"

#include "main/shim/controller.h"

#ifndef BT_STACK_CLEANUP_WAIT_MS

#define BT_STACK_CLEANUP_WAIT_MS 1000

#endif

// Validate or respond to various conditional compilation flags

#if BLE_PRIVACY_SPT != TRUE

static void event_init_stack(void* context);

static void event_start_up_stack(void* context);

static void event_shut_down_stack(void* context);

static void event_clean_up_stack(void* context);

static void event_clean_up_stack(std::promise<void> promise);

static void event_signal_stack_up(void* context);

static void event_signal_stack_down(void* context);

static void clean_up_stack() {

  // This is a synchronous process. Post it to the thread though, so

  // state modification only happens there.

  semaphore_t* semaphore = semaphore_new(0);

  management_thread.DoInThread(FROM_HERE,

                               base::Bind(event_clean_up_stack, semaphore));

  semaphore_wait(semaphore);

  semaphore_free(semaphore);

  std::promise<void> promise;

  auto future = promise.get_future();

  management_thread.DoInThread(

      FROM_HERE, base::BindOnce(event_clean_up_stack, std::move(promise)));

  auto status =

      future.wait_for(std::chrono::milliseconds(BT_STACK_CLEANUP_WAIT_MS));

  if (status == std::future_status::ready) {

    management_thread.ShutDown();

  } else {

    LOG_ERROR("cleanup could not be completed in time, abandon it");

  }

}

static bool get_stack_is_running() { return stack_is_running; }

}

// Synchronous function to clean up the stack

static void event_clean_up_stack(void* context) {

static void event_clean_up_stack(std::promise<void> promise) {

  if (!stack_is_initialized) {

    LOG_INFO("%s found the stack already in a clean state", __func__);

    goto cleanup;

  LOG_INFO("%s finished", __func__);

cleanup:;

  semaphore_t* semaphore = (semaphore_t*)context;

  if (semaphore) semaphore_post(semaphore);

  promise.set_value();

}

static void event_signal_stack_up(UNUSED_ATTR void* context) {