system: Remove location parameter from do_in_main_thread

It is not used in a meaningful way, and passing the argument
increases the .text size by several KiBs

Bug: 331817295
Test: m com.android.btservices
Flag: EXEMPT, mechanical refactor
Change-Id: I197d200df0de7d872aa724cf3a91550b755c638b

61 files changed, 852 insertions, 1043 deletions

diff --git a/system/bta/ag/bta_ag_api.cc b/system/bta/ag/bta_ag_api.cc
index 9d3dcd16da..6213846985 100644
--- a/system/bta/ag/bta_ag_api.cc
+++ b/system/bta/ag/bta_ag_api.cc
@@ -69,7 +69,7 @@ tBTA_STATUS BTA_AgEnable(tBTA_AG_CBACK* p_cback) {
     }
   }
   bta_sys_register(BTA_ID_AG, &bta_ag_reg);
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_api_enable, p_cback));
+  do_in_main_thread(base::BindOnce(&bta_ag_api_enable, p_cback));
   return BTA_SUCCESS;
 }
 
@@ -83,7 +83,7 @@ tBTA_STATUS BTA_AgEnable(tBTA_AG_CBACK* p_cback) {
  * Returns          void
  *
  ******************************************************************************/
-void BTA_AgDisable() { do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_api_disable)); }
+void BTA_AgDisable() { do_in_main_thread(base::BindOnce(&bta_ag_api_disable)); }
 
 /*******************************************************************************
  *
@@ -97,8 +97,8 @@ void BTA_AgDisable() { do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_api_d
  ******************************************************************************/
 void BTA_AgRegister(tBTA_SERVICE_MASK services, tBTA_AG_FEAT features,
                     const std::vector<std::string>& service_names, uint8_t app_id) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_api_register, services, features,
-                                              service_names, app_id));
+  do_in_main_thread(
+          base::BindOnce(&bta_ag_api_register, services, features, service_names, app_id));
 }
 
 /*******************************************************************************
@@ -112,8 +112,8 @@ void BTA_AgRegister(tBTA_SERVICE_MASK services, tBTA_AG_FEAT features,
  *
  ******************************************************************************/
 void BTA_AgDeregister(uint16_t handle) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                              BTA_AG_API_DEREGISTER_EVT, tBTA_AG_DATA::kEmpty));
+  do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_API_DEREGISTER_EVT,
+                                   tBTA_AG_DATA::kEmpty));
 }
 
 /*******************************************************************************
@@ -132,8 +132,8 @@ void BTA_AgDeregister(uint16_t handle) {
 void BTA_AgOpen(uint16_t handle, const RawAddress& bd_addr) {
   tBTA_AG_DATA data = {};
   data.api_open.bd_addr = bd_addr;
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                              BTA_AG_API_OPEN_EVT, data));
+  do_in_main_thread(
+          base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_API_OPEN_EVT, data));
 }
 
 /*******************************************************************************
@@ -148,8 +148,8 @@ void BTA_AgOpen(uint16_t handle, const RawAddress& bd_addr) {
  *
  ******************************************************************************/
 void BTA_AgClose(uint16_t handle) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                              BTA_AG_API_CLOSE_EVT, tBTA_AG_DATA::kEmpty));
+  do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_API_CLOSE_EVT,
+                                   tBTA_AG_DATA::kEmpty));
 }
 
 /*******************************************************************************
@@ -169,8 +169,8 @@ void BTA_AgClose(uint16_t handle) {
 void BTA_AgAudioOpen(uint16_t handle, tBTA_AG_PEER_CODEC disabled_codecs) {
   tBTA_AG_DATA data = {};
   data.api_audio_open.disabled_codecs = disabled_codecs;
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                              BTA_AG_API_AUDIO_OPEN_EVT, data));
+  do_in_main_thread(
+          base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_API_AUDIO_OPEN_EVT, data));
 }
 
 /*******************************************************************************
@@ -185,8 +185,8 @@ void BTA_AgAudioOpen(uint16_t handle, tBTA_AG_PEER_CODEC disabled_codecs) {
  *
  ******************************************************************************/
 void BTA_AgAudioClose(uint16_t handle) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                              BTA_AG_API_AUDIO_CLOSE_EVT, tBTA_AG_DATA::kEmpty));
+  do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_API_AUDIO_CLOSE_EVT,
+                                   tBTA_AG_DATA::kEmpty));
 }
 
 /*******************************************************************************
@@ -202,7 +202,7 @@ void BTA_AgAudioClose(uint16_t handle) {
  *
  ******************************************************************************/
 void BTA_AgResult(uint16_t handle, tBTA_AG_RES result, const tBTA_AG_RES_DATA& data) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_api_result, handle, result, data));
+  do_in_main_thread(base::BindOnce(&bta_ag_api_result, handle, result, data));
 }
 
 /*******************************************************************************
@@ -220,22 +220,22 @@ void BTA_AgResult(uint16_t handle, tBTA_AG_RES result, const tBTA_AG_RES_DATA& d
 void BTA_AgSetCodec(uint16_t handle, tBTA_AG_PEER_CODEC codec) {
   tBTA_AG_DATA data = {};
   data.api_setcodec.codec = codec;
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                              BTA_AG_API_SETCODEC_EVT, data));
+  do_in_main_thread(
+          base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_API_SETCODEC_EVT, data));
 }
 
 void BTA_AgSetScoOffloadEnabled(bool value) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_set_sco_offload_enabled, value));
+  do_in_main_thread(base::BindOnce(&bta_ag_set_sco_offload_enabled, value));
 }
 
 void BTA_AgSetScoAllowed(bool value) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_set_sco_allowed, value));
+  do_in_main_thread(base::BindOnce(&bta_ag_set_sco_allowed, value));
 }
 
 void BTA_AgSetActiveDevice(const RawAddress& active_device_addr) {
   if (active_device_addr.IsEmpty()) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&bta_clear_active_device));
+    do_in_main_thread(base::BindOnce(&bta_clear_active_device));
   } else {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_api_set_active_device, active_device_addr));
+    do_in_main_thread(base::BindOnce(&bta_ag_api_set_active_device, active_device_addr));
   }
 }
diff --git a/system/bta/ag/bta_ag_rfc.cc b/system/bta/ag/bta_ag_rfc.cc
index 653af93d84..72ce906765 100644
--- a/system/bta/ag/bta_ag_rfc.cc
+++ b/system/bta/ag/bta_ag_rfc.cc
@@ -86,8 +86,8 @@ static void bta_ag_port_cback(uint32_t /* code */, uint16_t port_handle, uint16_
       log::error("rfcomm data on an unopened control block {} peer_addr {} state {}", handle,
                  p_scb->peer_addr, bta_ag_state_str(p_scb->state));
     }
-    do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                                BTA_AG_RFC_DATA_EVT, tBTA_AG_DATA::kEmpty));
+    do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_RFC_DATA_EVT,
+                                     tBTA_AG_DATA::kEmpty));
   }
 }
 
@@ -147,7 +147,7 @@ static void bta_ag_mgmt_cback(const tPORT_RESULT code, uint16_t port_handle, uin
 
   tBTA_AG_DATA data = {};
   data.rfc.port_handle = port_handle;
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle, event, data));
+  do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, event, data));
 }
 
 /*******************************************************************************
@@ -360,8 +360,7 @@ void bta_ag_rfc_do_close(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
     /* Close API was called while AG is in Opening state.               */
     /* Need to trigger the state machine to send callback to the app    */
     /* and move back to INIT state.                                     */
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&bta_ag_sm_execute_by_handle, bta_ag_scb_to_idx(p_scb),
+    do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, bta_ag_scb_to_idx(p_scb),
                                      BTA_AG_RFC_CLOSE_EVT, tBTA_AG_DATA::kEmpty));
 
     /* Cancel SDP if it had been started. */
diff --git a/system/bta/ag/bta_ag_sco.cc b/system/bta/ag/bta_ag_sco.cc
index 15ab90542e..66360ed512 100644
--- a/system/bta/ag/bta_ag_sco.cc
+++ b/system/bta/ag/bta_ag_sco.cc
@@ -170,8 +170,8 @@ static void bta_ag_sco_conn_cback(uint16_t sco_idx) {
   }
 
   if (handle != 0) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                                BTA_AG_SCO_OPEN_EVT, tBTA_AG_DATA::kEmpty));
+    do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_SCO_OPEN_EVT,
+                                     tBTA_AG_DATA::kEmpty));
   } else {
     /* no match found; disconnect sco, init sco variables */
     bta_ag_cb.sco.p_curr_scb = nullptr;
@@ -292,8 +292,8 @@ static void bta_ag_sco_disc_cback(uint16_t sco_idx) {
 
     bta_ag_cb.sco.p_curr_scb->inuse_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_NONE;
 
-    do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute_by_handle, handle,
-                                                BTA_AG_SCO_CLOSE_EVT, tBTA_AG_DATA::kEmpty));
+    do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_SCO_CLOSE_EVT,
+                                     tBTA_AG_DATA::kEmpty));
   } else {
     /* no match found */
     log::verbose("no scb for ag_sco_disc_cback");
@@ -425,8 +425,8 @@ void bta_ag_create_sco(tBTA_AG_SCB* p_scb, bool is_orig) {
     log::warn("device {} is not active, active_device={}", p_scb->peer_addr, active_device_addr);
     if (bta_ag_cb.sco.p_curr_scb != nullptr && bta_ag_cb.sco.p_curr_scb->in_use &&
         p_scb == bta_ag_cb.sco.p_curr_scb) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(&bta_ag_sm_execute, p_scb, BTA_AG_SCO_CLOSE_EVT,
-                                                  tBTA_AG_DATA::kEmpty));
+      do_in_main_thread(base::BindOnce(&bta_ag_sm_execute, p_scb, BTA_AG_SCO_CLOSE_EVT,
+                                       tBTA_AG_DATA::kEmpty));
     }
     return;
   }
diff --git a/system/bta/ag/bta_ag_sdp.cc b/system/bta/ag/bta_ag_sdp.cc
index 25c3dd729c..f692307154 100644
--- a/system/bta/ag/bta_ag_sdp.cc
+++ b/system/bta/ag/bta_ag_sdp.cc
@@ -96,8 +96,7 @@ static void bta_ag_sdp_cback(uint16_t status, uint8_t idx) {
       event = BTA_AG_DISC_INT_RES_EVT;
     }
     tBTA_AG_DATA disc_result = {.disc_result = {.status = status}};
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&bta_ag_sm_execute_by_handle, idx, event, disc_result));
+    do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, idx, event, disc_result));
   }
 }
 
diff --git a/system/bta/dm/bta_dm_act.cc b/system/bta/dm/bta_dm_act.cc
index 6d5a0ba3d3..4ad49f1c07 100644
--- a/system/bta/dm/bta_dm_act.cc
+++ b/system/bta/dm/bta_dm_act.cc
@@ -632,7 +632,7 @@ static void handle_role_change(const RawAddress& bd_addr, tHCI_ROLE new_role,
 
 void BTA_dm_report_role_change(const RawAddress bd_addr, tHCI_ROLE new_role,
                                tHCI_STATUS hci_status) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(handle_role_change, bd_addr, new_role, hci_status));
+  do_in_main_thread(base::BindOnce(handle_role_change, bd_addr, new_role, hci_status));
 }
 
 void handle_remote_features_complete(const RawAddress& bd_addr) {
@@ -652,7 +652,7 @@ void handle_remote_features_complete(const RawAddress& bd_addr) {
 }
 
 void BTA_dm_notify_remote_features_complete(const RawAddress bd_addr) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(handle_remote_features_complete, bd_addr));
+  do_in_main_thread(base::BindOnce(handle_remote_features_complete, bd_addr));
 }
 
 static tBTA_DM_PEER_DEVICE* allocate_device_for(const RawAddress& bd_addr,
@@ -713,7 +713,7 @@ static void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport, ui
 }
 
 void BTA_dm_acl_up(const RawAddress bd_addr, tBT_TRANSPORT transport, uint16_t acl_handle) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_acl_up, bd_addr, transport, acl_handle));
+  do_in_main_thread(base::BindOnce(bta_dm_acl_up, bd_addr, transport, acl_handle));
 }
 
 static void bta_dm_acl_up_failed(const RawAddress bd_addr, tBT_TRANSPORT transport,
@@ -728,7 +728,7 @@ static void bta_dm_acl_up_failed(const RawAddress bd_addr, tBT_TRANSPORT transpo
 }
 
 void BTA_dm_acl_up_failed(const RawAddress bd_addr, tBT_TRANSPORT transport, tHCI_STATUS status) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_acl_up_failed, bd_addr, transport, status));
+  do_in_main_thread(base::BindOnce(bta_dm_acl_up_failed, bd_addr, transport, status));
 }
 
 static void bta_dm_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
@@ -812,7 +812,7 @@ static void bta_dm_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport)
 }
 
 void BTA_dm_acl_down(const RawAddress bd_addr, tBT_TRANSPORT transport) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_acl_down, bd_addr, transport));
+  do_in_main_thread(base::BindOnce(bta_dm_acl_down, bd_addr, transport));
 }
 
 /*******************************************************************************
diff --git a/system/bta/dm/bta_dm_api.cc b/system/bta/dm/bta_dm_api.cc
index a5e907234f..112496766e 100644
--- a/system/bta/dm/bta_dm_api.cc
+++ b/system/bta/dm/bta_dm_api.cc
@@ -59,7 +59,7 @@ void BTA_dm_init() {
 
 /** Enables bluetooth device under test mode */
 void BTA_EnableTestMode(void) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(base::IgnoreResult(BTM_EnableTestMode)));
+  do_in_main_thread(base::BindOnce(base::IgnoreResult(BTM_EnableTestMode)));
 }
 
 /** This function sets the Bluetooth name of local device */
@@ -67,7 +67,7 @@ void BTA_DmSetDeviceName(const char* p_name) {
   std::vector<uint8_t> name(BD_NAME_LEN + 1);
   bd_name_from_char_pointer(name.data(), p_name);
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_set_dev_name, name));
+  do_in_main_thread(base::BindOnce(bta_dm_set_dev_name, name));
 }
 
 /*******************************************************************************
@@ -177,8 +177,8 @@ tBTA_STATUS BTA_DmSetLocalDiRecord(tSDP_DI_RECORD* p_device_info, uint32_t* p_ha
 void BTA_DmSetBlePrefConnParams(const RawAddress& bd_addr, uint16_t min_conn_int,
                                 uint16_t max_conn_int, uint16_t peripheral_latency,
                                 uint16_t supervision_tout) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_ble_set_conn_params, bd_addr, min_conn_int,
-                                              max_conn_int, peripheral_latency, supervision_tout));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_set_conn_params, bd_addr, min_conn_int, max_conn_int,
+                                   peripheral_latency, supervision_tout));
 }
 
 /*******************************************************************************
@@ -202,8 +202,8 @@ void BTA_DmSetBlePrefConnParams(const RawAddress& bd_addr, uint16_t min_conn_int
 void BTA_DmBleUpdateConnectionParams(const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
                                      uint16_t latency, uint16_t timeout, uint16_t min_ce_len,
                                      uint16_t max_ce_len) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_ble_update_conn_params, bd_addr, min_int,
-                                              max_int, latency, timeout, min_ce_len, max_ce_len));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_update_conn_params, bd_addr, min_int, max_int,
+                                   latency, timeout, min_ce_len, max_ce_len));
 }
 
 /*******************************************************************************
@@ -233,12 +233,12 @@ void BTA_DmBleConfigLocalPrivacy(bool privacy_enable) {
  *
  ******************************************************************************/
 void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_ble_get_energy_info, p_cmpl_cback));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_get_energy_info, p_cmpl_cback));
 }
 
 /** This function is to set maximum LE data packet size */
 void BTA_DmBleRequestMaxTxDataLength(const RawAddress& remote_device) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_ble_set_data_length, remote_device));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_set_data_length, remote_device));
 }
 
 /*******************************************************************************
@@ -258,8 +258,7 @@ void BTA_DmBleRequestMaxTxDataLength(const RawAddress& remote_device) {
  ******************************************************************************/
 void BTA_DmBleScan(bool start, uint8_t duration_sec, bool low_latency_scan) {
   log::verbose("start = {}", start);
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(bta_dm_ble_scan, start, duration_sec, low_latency_scan));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_scan, start, duration_sec, low_latency_scan));
 }
 
 /*******************************************************************************
@@ -277,7 +276,7 @@ void BTA_DmBleScan(bool start, uint8_t duration_sec, bool low_latency_scan) {
  ******************************************************************************/
 void BTA_DmBleCsisObserve(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {
   log::verbose("enable = {}", observe);
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_ble_csis_observe, observe, p_results_cb));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_csis_observe, observe, p_results_cb));
 }
 
 /*******************************************************************************
@@ -291,7 +290,7 @@ void BTA_DmBleCsisObserve(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {
  ******************************************************************************/
 void BTA_DmClearEventFilter(void) {
   log::verbose("BTA_DmClearEventFilter");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_clear_event_filter));
+  do_in_main_thread(base::BindOnce(bta_dm_clear_event_filter));
 }
 
 /*******************************************************************************
@@ -305,7 +304,7 @@ void BTA_DmClearEventFilter(void) {
  ******************************************************************************/
 void BTA_DmClearEventMask(void) {
   log::verbose("BTA_DmClearEventMask");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_clear_event_mask));
+  do_in_main_thread(base::BindOnce(bta_dm_clear_event_mask));
 }
 
 /*******************************************************************************
@@ -319,7 +318,7 @@ void BTA_DmClearEventMask(void) {
  ******************************************************************************/
 void BTA_DmClearFilterAcceptList(void) {
   log::verbose("BTA_DmClearFilterAcceptList");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_clear_filter_accept_list));
+  do_in_main_thread(base::BindOnce(bta_dm_clear_filter_accept_list));
 }
 
 /*******************************************************************************
@@ -333,7 +332,7 @@ void BTA_DmClearFilterAcceptList(void) {
  ******************************************************************************/
 void BTA_DmLeRand(bluetooth::hci::LeRandCallback cb) {
   log::verbose("BTA_DmLeRand");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_le_rand, std::move(cb)));
+  do_in_main_thread(base::BindOnce(bta_dm_le_rand, std::move(cb)));
 }
 
 /*******************************************************************************
@@ -347,37 +346,34 @@ void BTA_DmLeRand(bluetooth::hci::LeRandCallback cb) {
  ******************************************************************************/
 void BTA_DmDisconnectAllAcls() {
   log::verbose("BTA_DmLeRand");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_disconnect_all_acls));
+  do_in_main_thread(base::BindOnce(bta_dm_disconnect_all_acls));
 }
 
 void BTA_DmSetEventFilterConnectionSetupAllDevices() {
   log::verbose("BTA_DmSetEventFilterConnectionSetupAllDevices");
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(bta_dm_set_event_filter_connection_setup_all_devices));
+  do_in_main_thread(base::BindOnce(bta_dm_set_event_filter_connection_setup_all_devices));
 }
 
 void BTA_DmAllowWakeByHid(std::vector<RawAddress> classic_hid_devices,
                           std::vector<std::pair<RawAddress, uint8_t>> le_hid_devices) {
   log::verbose("BTA_DmAllowWakeByHid");
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(bta_dm_allow_wake_by_hid, std::move(classic_hid_devices),
+  do_in_main_thread(base::BindOnce(bta_dm_allow_wake_by_hid, std::move(classic_hid_devices),
                                    std::move(le_hid_devices)));
 }
 
 void BTA_DmRestoreFilterAcceptList(std::vector<std::pair<RawAddress, uint8_t>> le_devices) {
   log::verbose("BTA_DmRestoreFilterAcceptList");
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(bta_dm_restore_filter_accept_list, std::move(le_devices)));
+  do_in_main_thread(base::BindOnce(bta_dm_restore_filter_accept_list, std::move(le_devices)));
 }
 
 void BTA_DmSetDefaultEventMaskExcept(uint64_t mask, uint64_t le_mask) {
   log::verbose("BTA_DmSetDefaultEventMaskExcept");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_set_default_event_mask_except, mask, le_mask));
+  do_in_main_thread(base::BindOnce(bta_dm_set_default_event_mask_except, mask, le_mask));
 }
 
 void BTA_DmSetEventFilterInquiryResultAllDevices() {
   log::verbose("BTA_DmSetEventFilterInquiryResultAllDevices");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_set_event_filter_inquiry_result_all_devices));
+  do_in_main_thread(base::BindOnce(bta_dm_set_event_filter_inquiry_result_all_devices));
 }
 
 /*******************************************************************************
@@ -391,7 +387,7 @@ void BTA_DmSetEventFilterInquiryResultAllDevices() {
  ******************************************************************************/
 void BTA_DmBleResetId(void) {
   log::verbose("BTA_DmBleResetId");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_ble_reset_id));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_reset_id));
 }
 
 /*******************************************************************************
@@ -413,8 +409,8 @@ void BTA_DmBleResetId(void) {
 void BTA_DmBleSubrateRequest(const RawAddress& bd_addr, uint16_t subrate_min, uint16_t subrate_max,
                              uint16_t max_latency, uint16_t cont_num, uint16_t timeout) {
   log::verbose("");
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_ble_subrate_request, bd_addr, subrate_min,
-                                              subrate_max, max_latency, cont_num, timeout));
+  do_in_main_thread(base::BindOnce(bta_dm_ble_subrate_request, bd_addr, subrate_min, subrate_max,
+                                   max_latency, cont_num, timeout));
 }
 
 bool BTA_DmCheckLeAudioCapable(const RawAddress& address) {
diff --git a/system/bta/dm/bta_dm_ci.cc b/system/bta/dm/bta_dm_ci.cc
index 7932d8374d..184a9de802 100644
--- a/system/bta/dm/bta_dm_ci.cc
+++ b/system/bta/dm/bta_dm_ci.cc
@@ -48,5 +48,5 @@ void bta_dm_ci_rmt_oob(bool accept, const RawAddress& bd_addr, const Octet16& c,
   msg->c = c;
   msg->r = r;
 
-  do_in_main_thread(FROM_HERE, base::Bind(bta_dm_ci_rmt_oob_act, base::Passed(&msg)));
+  do_in_main_thread(base::Bind(bta_dm_ci_rmt_oob_act, base::Passed(&msg)));
 }
diff --git a/system/bta/dm/bta_dm_device_search.cc b/system/bta/dm/bta_dm_device_search.cc
index 491adc42a1..a76cc0b592 100644
--- a/system/bta/dm/bta_dm_device_search.cc
+++ b/system/bta/dm/bta_dm_device_search.cc
@@ -83,8 +83,8 @@ static tBTA_DM_DEVICE_SEARCH_STATE bta_dm_search_get_state() {
 }
 
 static void post_search_evt(tBTA_DM_DEV_SEARCH_EVT event, std::unique_ptr<tBTA_DM_SEARCH_MSG> msg) {
-  if (do_in_main_thread(FROM_HERE, base::BindOnce(&bta_dm_search_sm_execute, event,
-                                                  std::move(msg))) != BT_STATUS_SUCCESS) {
+  if (do_in_main_thread(base::BindOnce(&bta_dm_search_sm_execute, event, std::move(msg))) !=
+      BT_STATUS_SUCCESS) {
     log::error("post_search_evt failed");
   }
 }
diff --git a/system/bta/dm/bta_dm_disc.cc b/system/bta/dm/bta_dm_disc.cc
index 16166e5265..c2a3f9c579 100644
--- a/system/bta/dm/bta_dm_disc.cc
+++ b/system/bta/dm/bta_dm_disc.cc
@@ -88,8 +88,8 @@ static bool is_same_device(const RawAddress& a, const RawAddress& b) {
 
 static void bta_dm_disc_sm_execute(tBTA_DM_DISC_EVT event, std::unique_ptr<tBTA_DM_MSG> msg);
 static void post_disc_evt(tBTA_DM_DISC_EVT event, std::unique_ptr<tBTA_DM_MSG> msg) {
-  if (do_in_main_thread(FROM_HERE, base::BindOnce(&bta_dm_disc_sm_execute, event,
-                                                  std::move(msg))) != BT_STATUS_SUCCESS) {
+  if (do_in_main_thread(base::BindOnce(&bta_dm_disc_sm_execute, event, std::move(msg))) !=
+      BT_STATUS_SUCCESS) {
     log::error("post_disc_evt failed");
   }
 }
@@ -253,8 +253,8 @@ void bta_dm_sdp_callback(const RawAddress& /* bd_addr */, tSDP_STATUS sdp_status
     return;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_dm_sdp_result, sdp_status,
-                                              bta_dm_discovery_cb.sdp_state.get()));
+  do_in_main_thread(
+          base::BindOnce(&bta_dm_sdp_result, sdp_status, bta_dm_discovery_cb.sdp_state.get()));
 }
 
 /** Callback of peer's DIS reply. This is only called for floss */
diff --git a/system/bta/dm/bta_dm_disc_legacy.cc b/system/bta/dm/bta_dm_disc_legacy.cc
index e8a92d24be..fc01c3a025 100644
--- a/system/bta/dm/bta_dm_disc_legacy.cc
+++ b/system/bta/dm/bta_dm_disc_legacy.cc
@@ -82,8 +82,8 @@ tBTA_DM_SEARCH_CB bta_dm_search_cb;
 
 static void bta_dm_search_sm_execute(tBTA_DM_EVT event, std::unique_ptr<tBTA_DM_MSG> msg);
 static void post_disc_evt(tBTA_DM_EVT event, std::unique_ptr<tBTA_DM_MSG> msg) {
-  if (do_in_main_thread(FROM_HERE, base::BindOnce(&bta_dm_search_sm_execute, event,
-                                                  std::move(msg))) != BT_STATUS_SUCCESS) {
+  if (do_in_main_thread(base::BindOnce(&bta_dm_search_sm_execute, event, std::move(msg))) !=
+      BT_STATUS_SUCCESS) {
     log::error("post_disc_evt failed");
   }
 }
diff --git a/system/bta/dm/bta_dm_pm.cc b/system/bta/dm/bta_dm_pm.cc
index 72cc580a16..0be4bb0c45 100644
--- a/system/bta/dm/bta_dm_pm.cc
+++ b/system/bta/dm/bta_dm_pm.cc
@@ -998,8 +998,7 @@ static void bta_dm_pm_btm_status(const RawAddress& bd_addr, tBTM_PM_STATUS statu
 /** BTM power manager callback */
 static void bta_dm_pm_btm_cback(const RawAddress& bd_addr, tBTM_PM_STATUS status, uint16_t value,
                                 tHCI_STATUS hci_status) {
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(bta_dm_pm_btm_status, bd_addr, status, value, hci_status));
+  do_in_main_thread(base::BindOnce(bta_dm_pm_btm_status, bd_addr, status, value, hci_status));
 }
 
 /*******************************************************************************
@@ -1043,8 +1042,8 @@ static void bta_dm_pm_timer_cback(void* data) {
     return;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_pm_timer, bta_dm_cb.pm_timer[i].peer_bdaddr,
-                                              bta_dm_cb.pm_timer[i].pm_action[j]));
+  do_in_main_thread(base::BindOnce(bta_dm_pm_timer, bta_dm_cb.pm_timer[i].peer_bdaddr,
+                                   bta_dm_cb.pm_timer[i].pm_action[j]));
 }
 
 /** Process pm status event from btm */
diff --git a/system/bta/gatt/bta_gattc_act.cc b/system/bta/gatt/bta_gattc_act.cc
index 65a6275f62..c0a01da22e 100644
--- a/system/bta/gatt/bta_gattc_act.cc
+++ b/system/bta/gatt/bta_gattc_act.cc
@@ -196,7 +196,7 @@ void bta_gattc_register(const Uuid& app_uuid, tBTA_GATTC_CBACK* p_cback, BtaAppR
         log::debug("Registered GATT client interface {} with uuid={}, starting it on main thread",
                    client_if, app_uuid.ToString());
 
-        do_in_main_thread(FROM_HERE, base::BindOnce(&bta_gattc_start_if, client_if));
+        do_in_main_thread(base::BindOnce(&bta_gattc_start_if, client_if));
 
         status = GATT_SUCCESS;
         break;
@@ -1378,7 +1378,7 @@ static void bta_gattc_enc_cmpl_cback(tGATT_IF gattc_if, const RawAddress& bda) {
 
   log::verbose("cif:{}", gattc_if);
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_gattc_process_enc_cmpl, gattc_if, bda));
+  do_in_main_thread(base::BindOnce(&bta_gattc_process_enc_cmpl, gattc_if, bda));
 }
 
 /** process refresh API to delete cache and start a new discovery if currently
diff --git a/system/bta/gatt/bta_gattc_api.cc b/system/bta/gatt/bta_gattc_api.cc
index 7dc3140a97..2e32ceebaa 100644
--- a/system/bta/gatt/bta_gattc_api.cc
+++ b/system/bta/gatt/bta_gattc_api.cc
@@ -68,7 +68,7 @@ void BTA_GATTC_Disable(void) {
     return;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_gattc_disable));
+  do_in_main_thread(base::BindOnce(&bta_gattc_disable));
   bta_sys_deregister(BTA_ID_GATTC);
 }
 
@@ -87,8 +87,8 @@ void BTA_GATTC_AppRegister(tBTA_GATTC_CBACK* p_client_cb, BtaAppRegisterCallback
 
   Uuid uuid = Uuid::From128BitBE(bluetooth::os::GenerateRandom<Uuid::kNumBytes128>());
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_gattc_register, uuid, p_client_cb, std::move(cb),
-                                              eatt_support));
+  do_in_main_thread(
+          base::BindOnce(&bta_gattc_register, uuid, p_client_cb, std::move(cb), eatt_support));
 }
 
 static void app_deregister_impl(tGATT_IF client_if) {
@@ -113,7 +113,7 @@ static void app_deregister_impl(tGATT_IF client_if) {
  *
  ******************************************************************************/
 void BTA_GATTC_AppDeregister(tGATT_IF client_if) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&app_deregister_impl, client_if));
+  do_in_main_thread(base::BindOnce(&app_deregister_impl, client_if));
 }
 
 /*******************************************************************************
@@ -273,12 +273,10 @@ void BTA_GATTC_ServiceSearchRequest(uint16_t conn_id, Uuid p_srvc_uuid) {
 }
 
 void BTA_GATTC_DiscoverServiceByUuid(uint16_t conn_id, const Uuid& srvc_uuid) {
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  base::IgnoreResult<tGATT_STATUS (*)(uint16_t, tGATT_DISC_TYPE, uint16_t, uint16_t,
-                                                      const Uuid&)>(&GATTC_Discover),
-                  conn_id, GATT_DISC_SRVC_BY_UUID, 0x0001, 0xFFFF, srvc_uuid));
+  do_in_main_thread(base::BindOnce(
+          base::IgnoreResult<tGATT_STATUS (*)(uint16_t, tGATT_DISC_TYPE, uint16_t, uint16_t,
+                                              const Uuid&)>(&GATTC_Discover),
+          conn_id, GATT_DISC_SRVC_BY_UUID, 0x0001, 0xFFFF, srvc_uuid));
 }
 
 /*******************************************************************************
@@ -742,5 +740,5 @@ tGATT_STATUS BTA_GATTC_DeregisterForNotifications(tGATT_IF client_if, const RawA
  *
  ******************************************************************************/
 void BTA_GATTC_Refresh(const RawAddress& remote_bda) {
-  do_in_main_thread(FROM_HERE, base::Bind(&bta_gattc_process_api_refresh, remote_bda));
+  do_in_main_thread(base::Bind(&bta_gattc_process_api_refresh, remote_bda));
 }
diff --git a/system/bta/gatt/bta_gatts_api.cc b/system/bta/gatt/bta_gatts_api.cc
index 7204ef36f2..4ceb8fe72a 100644
--- a/system/bta/gatt/bta_gatts_api.cc
+++ b/system/bta/gatt/bta_gatts_api.cc
@@ -172,8 +172,8 @@ void bta_gatts_add_service_impl(tGATT_IF server_if, std::vector<btgatt_db_elemen
  ******************************************************************************/
 void BTA_GATTS_AddService(tGATT_IF server_if, std::vector<btgatt_db_element_t> service,
                           BTA_GATTS_AddServiceCb cb) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_gatts_add_service_impl, server_if,
-                                              std::move(service), std::move(cb)));
+  do_in_main_thread(base::BindOnce(&bta_gatts_add_service_impl, server_if, std::move(service),
+                                   std::move(cb)));
 }
 
 /*******************************************************************************
diff --git a/system/bta/hearing_aid/hearing_aid_audio_source.cc b/system/bta/hearing_aid/hearing_aid_audio_source.cc
index 7f6535c681..429bb4f0ce 100644
--- a/system/bta/hearing_aid/hearing_aid_audio_source.cc
+++ b/system/bta/hearing_aid/hearing_aid_audio_source.cc
@@ -159,12 +159,12 @@ void hearing_aid_data_cb(tUIPC_CH_ID, tUIPC_EVENT event) {
       UIPC_Ioctl(*uipc_hearing_aid, UIPC_CH_ID_AV_AUDIO, UIPC_SET_READ_POLL_TMO,
                  reinterpret_cast<void*>(0));
 
-      do_in_main_thread(FROM_HERE, base::BindOnce(start_audio_ticks));
+      do_in_main_thread(base::BindOnce(start_audio_ticks));
       break;
     case UIPC_CLOSE_EVT:
       log::info("UIPC_CLOSE_EVT");
       hearing_aid_send_ack(HEARING_AID_CTRL_ACK_SUCCESS);
-      do_in_main_thread(FROM_HERE, base::BindOnce(stop_audio_ticks));
+      do_in_main_thread(base::BindOnce(stop_audio_ticks));
       break;
     default:
       log::error("Hearing Aid audio data event not recognized: {}", event);
@@ -340,14 +340,14 @@ bool hearing_aid_on_resume_req(bool start_media_task) {
   }
   bt_status_t status;
   if (start_media_task) {
-    status = do_in_main_thread(
-            FROM_HERE, base::BindOnce(&HearingAidAudioReceiver::OnAudioResume,
-                                      base::Unretained(localAudioReceiver), start_audio_ticks));
+    status = do_in_main_thread(base::BindOnce(&HearingAidAudioReceiver::OnAudioResume,
+                                              base::Unretained(localAudioReceiver),
+                                              start_audio_ticks));
   } else {
     auto start_dummy_ticks = []() { log::info("start_audio_ticks: waiting for data path opened"); };
-    status = do_in_main_thread(
-            FROM_HERE, base::BindOnce(&HearingAidAudioReceiver::OnAudioResume,
-                                      base::Unretained(localAudioReceiver), start_dummy_ticks));
+    status = do_in_main_thread(base::BindOnce(&HearingAidAudioReceiver::OnAudioResume,
+                                              base::Unretained(localAudioReceiver),
+                                              start_dummy_ticks));
   }
   if (status != BT_STATUS_SUCCESS) {
     log::error("HEARING_AID_CTRL_CMD_START: do_in_main_thread err={}", status);
@@ -361,9 +361,9 @@ bool hearing_aid_on_suspend_req() {
     log::error("HEARING_AID_CTRL_CMD_SUSPEND: audio receiver not started");
     return false;
   }
-  bt_status_t status = do_in_main_thread(
-          FROM_HERE, base::BindOnce(&HearingAidAudioReceiver::OnAudioSuspend,
-                                    base::Unretained(localAudioReceiver), stop_audio_ticks));
+  bt_status_t status =
+          do_in_main_thread(base::BindOnce(&HearingAidAudioReceiver::OnAudioSuspend,
+                                           base::Unretained(localAudioReceiver), stop_audio_ticks));
   if (status != BT_STATUS_SUCCESS) {
     log::error("HEARING_AID_CTRL_CMD_SUSPEND: do_in_main_thread err={}", status);
     return false;
diff --git a/system/bta/jv/bta_jv_api.cc b/system/bta/jv/bta_jv_api.cc
index 877a234953..63456511b1 100644
--- a/system/bta/jv/bta_jv_api.cc
+++ b/system/bta/jv/bta_jv_api.cc
@@ -79,7 +79,7 @@ tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK* p_cback) {
 
   bta_jv_enabled = true;
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_enable, p_cback));
+  do_in_main_thread(Bind(&bta_jv_enable, p_cback));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -89,7 +89,7 @@ void BTA_JvDisable(void) {
 
   bta_jv_enabled = false;
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_disable));
+  do_in_main_thread(Bind(&bta_jv_disable));
 }
 
 /*******************************************************************************
@@ -117,7 +117,7 @@ void BTA_JvDisable(void) {
 void BTA_JvGetChannelId(tBTA_JV_CONN_TYPE conn_type, uint32_t id, int32_t channel) {
   log::verbose("conn_type:{}, id:{}, channel:{}", bta_jv_conn_type_text(conn_type), id, channel);
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_get_channel_id, conn_type, channel, id, id));
+  do_in_main_thread(Bind(&bta_jv_get_channel_id, conn_type, channel, id, id));
 }
 
 /*******************************************************************************
@@ -137,7 +137,7 @@ void BTA_JvGetChannelId(tBTA_JV_CONN_TYPE conn_type, uint32_t id, int32_t channe
 tBTA_JV_STATUS BTA_JvFreeChannel(uint16_t channel, tBTA_JV_CONN_TYPE conn_type) {
   log::verbose("channel:{}, conn_type:{}", channel, bta_jv_conn_type_text(conn_type));
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_free_scn, conn_type, channel));
+  do_in_main_thread(Bind(&bta_jv_free_scn, conn_type, channel));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -161,8 +161,8 @@ tBTA_JV_STATUS BTA_JvStartDiscovery(const RawAddress& bd_addr, uint16_t num_uuid
   Uuid* uuid_list_copy = new Uuid[num_uuid];
   memcpy(uuid_list_copy, p_uuid_list, num_uuid * sizeof(Uuid));
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_start_discovery, bd_addr, num_uuid,
-                                    base::Owned(uuid_list_copy), rfcomm_slot_id));
+  do_in_main_thread(Bind(&bta_jv_start_discovery, bd_addr, num_uuid, base::Owned(uuid_list_copy),
+                         rfcomm_slot_id));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -181,7 +181,7 @@ tBTA_JV_STATUS BTA_JvStartDiscovery(const RawAddress& bd_addr, uint16_t num_uuid
 tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id) {
   log::verbose("rfcomm_slot_id: {}", rfcomm_slot_id);
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_create_record, rfcomm_slot_id));
+  do_in_main_thread(Bind(&bta_jv_create_record, rfcomm_slot_id));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -198,7 +198,7 @@ tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id) {
 tBTA_JV_STATUS BTA_JvDeleteRecord(uint32_t handle) {
   log::verbose("handle:{}", handle);
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_delete_record, handle));
+  do_in_main_thread(Bind(&bta_jv_delete_record, handle));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -223,9 +223,9 @@ void BTA_JvL2capConnect(tBTA_JV_CONN_TYPE conn_type, tBTA_SEC sec_mask,
                bta_jv_conn_type_text(conn_type), remote_psm, peer_bd_addr, l2cap_socket_id);
   log::assert_that(p_cback != nullptr, "assert failed: p_cback != nullptr");
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_l2cap_connect, conn_type, sec_mask, remote_psm, rx_mtu,
-                                    peer_bd_addr, base::Passed(&cfg), base::Passed(&ertm_info),
-                                    p_cback, l2cap_socket_id));
+  do_in_main_thread(Bind(&bta_jv_l2cap_connect, conn_type, sec_mask, remote_psm, rx_mtu,
+                         peer_bd_addr, base::Passed(&cfg), base::Passed(&ertm_info), p_cback,
+                         l2cap_socket_id));
 }
 
 /*******************************************************************************
@@ -245,7 +245,7 @@ tBTA_JV_STATUS BTA_JvL2capClose(uint32_t handle) {
     return tBTA_JV_STATUS::FAILURE;
   }
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_l2cap_close, handle, &bta_jv_cb.l2c_cb[handle]));
+  do_in_main_thread(Bind(&bta_jv_l2cap_close, handle, &bta_jv_cb.l2c_cb[handle]));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -271,8 +271,7 @@ void BTA_JvL2capStartServer(tBTA_JV_CONN_TYPE conn_type, tBTA_SEC sec_mask,
                local_psm, l2cap_socket_id);
   CHECK(p_cback);
 
-  do_in_main_thread(FROM_HERE,
-                    Bind(&bta_jv_l2cap_start_server, conn_type, sec_mask, local_psm, rx_mtu,
+  do_in_main_thread(Bind(&bta_jv_l2cap_start_server, conn_type, sec_mask, local_psm, rx_mtu,
                          base::Passed(&cfg), base::Passed(&ertm_info), p_cback, l2cap_socket_id));
 }
 
@@ -290,7 +289,7 @@ void BTA_JvL2capStartServer(tBTA_JV_CONN_TYPE conn_type, tBTA_SEC sec_mask,
 tBTA_JV_STATUS BTA_JvL2capStopServer(uint16_t local_psm, uint32_t l2cap_socket_id) {
   log::verbose("local_psm:{}, l2cap_socket_id:{}", local_psm, l2cap_socket_id);
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_l2cap_stop_server, local_psm, l2cap_socket_id));
+  do_in_main_thread(Bind(&bta_jv_l2cap_stop_server, local_psm, l2cap_socket_id));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -377,8 +376,8 @@ tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id, BT_HDR* msg, u
     return tBTA_JV_STATUS::FAILURE;
   }
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_l2cap_write, handle, req_id, msg, user_id,
-                                    &bta_jv_cb.l2c_cb[handle]));
+  do_in_main_thread(
+          Bind(&bta_jv_l2cap_write, handle, req_id, msg, user_id, &bta_jv_cb.l2c_cb[handle]));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -408,8 +407,8 @@ tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask, uint8_t remote_scn,
     return tBTA_JV_STATUS::FAILURE; /* Nothing to do */
   }
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_rfcomm_connect, sec_mask, remote_scn, peer_bd_addr,
-                                    p_cback, rfcomm_slot_id));
+  do_in_main_thread(Bind(&bta_jv_rfcomm_connect, sec_mask, remote_scn, peer_bd_addr, p_cback,
+                         rfcomm_slot_id));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -434,7 +433,7 @@ tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, uint32_t rfcomm_slot_id) {
     return tBTA_JV_STATUS::FAILURE;
   }
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_rfcomm_close, handle, rfcomm_slot_id));
+  do_in_main_thread(Bind(&bta_jv_rfcomm_close, handle, rfcomm_slot_id));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -469,8 +468,8 @@ tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask, uint8_t local_scn, uin
     max_session = BTA_JV_MAX_RFC_SR_SESSION;
   }
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_rfcomm_start_server, sec_mask, local_scn, max_session,
-                                    p_cback, rfcomm_slot_id));
+  do_in_main_thread(Bind(&bta_jv_rfcomm_start_server, sec_mask, local_scn, max_session, p_cback,
+                         rfcomm_slot_id));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -488,7 +487,7 @@ tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask, uint8_t local_scn, uin
 tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle, uint32_t rfcomm_slot_id) {
   log::verbose("handle:{}, rfcomm_slot_id:{}", handle, rfcomm_slot_id);
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_rfcomm_stop_server, handle, rfcomm_slot_id));
+  do_in_main_thread(Bind(&bta_jv_rfcomm_stop_server, handle, rfcomm_slot_id));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -536,8 +535,8 @@ tBTA_JV_STATUS BTA_JvRfcommWrite(uint32_t handle, uint32_t req_id) {
   log::verbose("write ok");
 
   tBTA_JV_RFC_CB* p_cb = &bta_jv_cb.rfc_cb[hi];
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_rfcomm_write, handle, req_id, p_cb,
-                                    &bta_jv_cb.port_cb[p_cb->rfc_hdl[si] - 1]));
+  do_in_main_thread(Bind(&bta_jv_rfcomm_write, handle, req_id, p_cb,
+                         &bta_jv_cb.port_cb[p_cb->rfc_hdl[si] - 1]));
   return tBTA_JV_STATUS::SUCCESS;
 }
 
@@ -568,6 +567,6 @@ tBTA_JV_STATUS BTA_JvSetPmProfile(uint32_t handle, tBTA_JV_PM_ID app_id,
                                   tBTA_JV_CONN_STATE init_st) {
   log::verbose("handle:{}, app_id:{}, init_st:{}", handle, app_id, handle);
 
-  do_in_main_thread(FROM_HERE, Bind(&bta_jv_set_pm_profile, handle, app_id, init_st));
+  do_in_main_thread(Bind(&bta_jv_set_pm_profile, handle, app_id, init_st));
   return tBTA_JV_STATUS::SUCCESS;
 }
diff --git a/system/bta/le_audio/audio_hal_client/audio_hal_client_test.cc b/system/bta/le_audio/audio_hal_client/audio_hal_client_test.cc
index 7c9c4c8b46..592fcd048b 100644
--- a/system/bta/le_audio/audio_hal_client/audio_hal_client_test.cc
+++ b/system/bta/le_audio/audio_hal_client/audio_hal_client_test.cc
@@ -53,9 +53,9 @@ using namespace bluetooth;
 
 bluetooth::common::MessageLoopThread message_loop_thread("test message loop");
 bluetooth::common::MessageLoopThread* get_main_thread() { return &message_loop_thread; }
-bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure task) {
-  if (!message_loop_thread.DoInThread(from_here, std::move(task))) {
-    log::error("failed from {}", from_here.ToString());
+bt_status_t do_in_main_thread(base::OnceClosure task) {
+  if (!message_loop_thread.DoInThread(FROM_HERE, std::move(task))) {
+    log::error("failed to post task to task runner!");
     return BT_STATUS_FAIL;
   }
   return BT_STATUS_SUCCESS;
diff --git a/system/bta/le_audio/audio_hal_client/audio_sink_hal_client.cc b/system/bta/le_audio/audio_hal_client/audio_sink_hal_client.cc
index 5678852a39..4b82b4cad0 100644
--- a/system/bta/le_audio/audio_hal_client/audio_sink_hal_client.cc
+++ b/system/bta/le_audio/audio_hal_client/audio_sink_hal_client.cc
@@ -128,9 +128,9 @@ bool SinkImpl::OnResumeReq(bool start_media_task) {
     return false;
   }
 
-  bt_status_t status = do_in_main_thread(
-          FROM_HERE, base::BindOnce(&LeAudioSinkAudioHalClient::Callbacks::OnAudioResume,
-                                    audioSinkCallbacks_->weak_factory_.GetWeakPtr()));
+  bt_status_t status =
+          do_in_main_thread(base::BindOnce(&LeAudioSinkAudioHalClient::Callbacks::OnAudioResume,
+                                           audioSinkCallbacks_->weak_factory_.GetWeakPtr()));
   if (status == BT_STATUS_SUCCESS) {
     return true;
   }
@@ -145,9 +145,9 @@ bool SinkImpl::OnSuspendReq() {
     return false;
   }
 
-  bt_status_t status = do_in_main_thread(
-          FROM_HERE, base::BindOnce(&LeAudioSinkAudioHalClient::Callbacks::OnAudioSuspend,
-                                    audioSinkCallbacks_->weak_factory_.GetWeakPtr()));
+  bt_status_t status =
+          do_in_main_thread(base::BindOnce(&LeAudioSinkAudioHalClient::Callbacks::OnAudioSuspend,
+                                           audioSinkCallbacks_->weak_factory_.GetWeakPtr()));
   if (status == BT_STATUS_SUCCESS) {
     return true;
   }
@@ -166,7 +166,6 @@ bool SinkImpl::OnMetadataUpdateReq(const sink_metadata_v7_t& sink_metadata) {
           sink_metadata.tracks, sink_metadata.tracks + sink_metadata.track_count);
 
   bt_status_t status = do_in_main_thread(
-          FROM_HERE,
           base::BindOnce(&LeAudioSinkAudioHalClient::Callbacks::OnAudioMetadataUpdate,
                          audioSinkCallbacks_->weak_factory_.GetWeakPtr(), std::move(metadata)));
   if (status == BT_STATUS_SUCCESS) {
diff --git a/system/bta/le_audio/audio_hal_client/audio_source_hal_client.cc b/system/bta/le_audio/audio_hal_client/audio_source_hal_client.cc
index 94ca1f4cbc..2440af4686 100644
--- a/system/bta/le_audio/audio_hal_client/audio_source_hal_client.cc
+++ b/system/bta/le_audio/audio_hal_client/audio_source_hal_client.cc
@@ -178,9 +178,9 @@ bool SourceImpl::OnResumeReq(bool start_media_task) {
     log::error("audioSourceCallbacks_ not set");
     return false;
   }
-  bt_status_t status = do_in_main_thread(
-          FROM_HERE, base::BindOnce(&LeAudioSourceAudioHalClient::Callbacks::OnAudioResume,
-                                    audioSourceCallbacks_->weak_factory_.GetWeakPtr()));
+  bt_status_t status =
+          do_in_main_thread(base::BindOnce(&LeAudioSourceAudioHalClient::Callbacks::OnAudioResume,
+                                           audioSourceCallbacks_->weak_factory_.GetWeakPtr()));
   if (status == BT_STATUS_SUCCESS) {
     return true;
   }
@@ -284,9 +284,9 @@ bool SourceImpl::OnSuspendReq() {
     return false;
   }
 
-  bt_status_t status = do_in_main_thread(
-          FROM_HERE, base::BindOnce(&LeAudioSourceAudioHalClient::Callbacks::OnAudioSuspend,
-                                    audioSourceCallbacks_->weak_factory_.GetWeakPtr()));
+  bt_status_t status =
+          do_in_main_thread(base::BindOnce(&LeAudioSourceAudioHalClient::Callbacks::OnAudioSuspend,
+                                           audioSourceCallbacks_->weak_factory_.GetWeakPtr()));
   if (status == BT_STATUS_SUCCESS) {
     return true;
   }
@@ -306,10 +306,9 @@ bool SourceImpl::OnMetadataUpdateReq(const source_metadata_v7_t& source_metadata
   std::vector<struct playback_track_metadata_v7> metadata(
           source_metadata.tracks, source_metadata.tracks + source_metadata.track_count);
 
-  bt_status_t status = do_in_main_thread(
-          FROM_HERE, base::BindOnce(&LeAudioSourceAudioHalClient::Callbacks::OnAudioMetadataUpdate,
-                                    audioSourceCallbacks_->weak_factory_.GetWeakPtr(),
-                                    std::move(metadata), dsa_mode));
+  bt_status_t status = do_in_main_thread(base::BindOnce(
+          &LeAudioSourceAudioHalClient::Callbacks::OnAudioMetadataUpdate,
+          audioSourceCallbacks_->weak_factory_.GetWeakPtr(), std::move(metadata), dsa_mode));
   if (status == BT_STATUS_SUCCESS) {
     return true;
   }
diff --git a/system/bta/le_audio/broadcaster/broadcaster_test.cc b/system/bta/le_audio/broadcaster/broadcaster_test.cc
index 6e86a504e4..ac07f64458 100644
--- a/system/bta/le_audio/broadcaster/broadcaster_test.cc
+++ b/system/bta/le_audio/broadcaster/broadcaster_test.cc
@@ -97,17 +97,17 @@ bluetooth::common::MessageLoopThread message_loop_thread("test message loop");
 bluetooth::common::MessageLoopThread* get_main_thread() { return &message_loop_thread; }
 void invoke_switch_buffer_size_cb(bool is_low_latency_buffer_size) {}
 
-bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure task) {
+bt_status_t do_in_main_thread(base::OnceClosure task) {
   // Wrap the task with task counter so we could later know if there are
   // any callbacks scheduled and we should wait before performing some actions
   if (!message_loop_thread.DoInThread(
-              from_here, base::BindOnce(
+              FROM_HERE, base::BindOnce(
                                  [](base::OnceClosure task, std::atomic<int>& num_async_tasks) {
                                    std::move(task).Run();
                                    num_async_tasks--;
                                  },
                                  std::move(task), std::ref(num_async_tasks)))) {
-    log::error("failed from {}", from_here.ToString());
+    log::error("failed to post task to task runner!");
     return BT_STATUS_FAIL;
   }
   num_async_tasks++;
diff --git a/system/bta/le_audio/client.cc b/system/bta/le_audio/client.cc
index bfaba87854..05c1687eb2 100644
--- a/system/bta/le_audio/client.cc
+++ b/system/bta/le_audio/client.cc
@@ -2216,7 +2216,6 @@ public:
   void scheduleGroupConnectedCheck(int group_id) {
     log::info("Schedule group_id {} connected check.", group_id);
     do_in_main_thread_delayed(
-            FROM_HERE,
             base::BindOnce(&LeAudioClientImpl::checkGroupConnectionStateAfterMemberDisconnect,
                            weak_factory_.GetWeakPtr(), group_id),
             std::chrono::milliseconds(kGroupConnectedWatchDelayMs));
@@ -2235,7 +2234,6 @@ public:
   void scheduleAutoConnect(RawAddress& address) {
     log::info("Schedule auto connect {}", address);
     do_in_main_thread_delayed(
-            FROM_HERE,
             base::BindOnce(&LeAudioClientImpl::autoConnect, weak_factory_.GetWeakPtr(), address),
             std::chrono::milliseconds(kAutoConnectAfterOwnDisconnectDelayMs));
   }
@@ -2262,8 +2260,7 @@ public:
 
   void scheduleRecoveryReconnect(RawAddress& address) {
     log::info("Schedule reconnecting to {} after timeout on state machine.", address);
-    do_in_main_thread_delayed(FROM_HERE,
-                              base::BindOnce(&LeAudioClientImpl::recoveryReconnect,
+    do_in_main_thread_delayed(base::BindOnce(&LeAudioClientImpl::recoveryReconnect,
                                              weak_factory_.GetWeakPtr(), address),
                               std::chrono::milliseconds(kRecoveryReconnectDelayMs));
   }
@@ -2293,8 +2290,7 @@ public:
    */
   void scheduleGuardForCsisAdd(RawAddress& address) {
     log::info("Schedule reconnecting to {} after timeout on state machine.", address);
-    do_in_main_thread_delayed(FROM_HERE,
-                              base::BindOnce(&LeAudioClientImpl::checkIfGroupMember,
+    do_in_main_thread_delayed(base::BindOnce(&LeAudioClientImpl::checkIfGroupMember,
                                              weak_factory_.GetWeakPtr(), address),
                               std::chrono::milliseconds(kCsisGroupMemberDelayMs));
   }
@@ -3047,8 +3043,7 @@ public:
 
   void scheduleAttachDeviceToTheStream(const RawAddress& addr) {
     log::info("Device {} scheduler for stream", addr);
-    do_in_main_thread_delayed(FROM_HERE,
-                              base::BindOnce(&LeAudioClientImpl::restartAttachToTheStream,
+    do_in_main_thread_delayed(base::BindOnce(&LeAudioClientImpl::restartAttachToTheStream,
                                              weak_factory_.GetWeakPtr(), addr),
                               std::chrono::milliseconds(kDeviceAttachDelayMs));
   }
diff --git a/system/bta/le_audio/le_audio_client_test.cc b/system/bta/le_audio/le_audio_client_test.cc
index c2cc5556f7..9f9351e2d1 100644
--- a/system/bta/le_audio/le_audio_client_test.cc
+++ b/system/bta/le_audio/le_audio_client_test.cc
@@ -123,7 +123,7 @@ static base::MessageLoop* message_loop_;
 bluetooth::common::MessageLoopThread message_loop_thread("test message loop");
 bluetooth::common::MessageLoopThread* get_main_thread() { return &message_loop_thread; }
 
-bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure task) {
+bt_status_t do_in_main_thread(base::OnceClosure task) {
   if (!message_loop_) {
     return BT_STATUS_FAIL;
   }
@@ -131,23 +131,22 @@ bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure
   // Wrap the task with task counter so we could later know if there are
   // any callbacks scheduled and we should wait before performing some actions
   if (!message_loop_thread.DoInThread(
-              from_here, base::BindOnce(
+              FROM_HERE, base::BindOnce(
                                  [](base::OnceClosure task, std::atomic<int>& num_async_tasks) {
                                    std::move(task).Run();
                                    num_async_tasks--;
                                  },
                                  std::move(task), std::ref(num_async_tasks)))) {
-    bluetooth::log::error("failed from {}", from_here.ToString());
+    bluetooth::log::error("failed to post task to task runner!");
     return BT_STATUS_FAIL;
   }
   num_async_tasks++;
   return BT_STATUS_SUCCESS;
 }
 
-bt_status_t do_in_main_thread_delayed(const base::Location& from_here, base::OnceClosure task,
-                                      std::chrono::microseconds delay) {
+bt_status_t do_in_main_thread_delayed(base::OnceClosure task, std::chrono::microseconds delay) {
   /* For testing purpose it is ok to just skip delay */
-  return do_in_main_thread(from_here, std::move(task));
+  return do_in_main_thread(std::move(task));
 }
 
 base::MessageLoop* get_main_message_loop() { return message_loop_; }
@@ -451,31 +450,26 @@ protected:
     }
 
     bool first_device = (group_members_num == 1);
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(
-                              [](const RawAddress& addr, int group_id, bluetooth::Uuid uuid,
-                                 bluetooth::groups::DeviceGroupsCallbacks* group_callbacks,
-                                 bool first_device) {
-                                if (first_device) {
-                                  group_callbacks->OnGroupAdded(addr, uuid, group_id);
-                                } else {
-                                  group_callbacks->OnGroupMemberAdded(addr, group_id);
-                                }
-                              },
-                              address, group_id, uuid, base::Unretained(this->group_callbacks_),
-                              first_device));
+    do_in_main_thread(base::BindOnce(
+            [](const RawAddress& addr, int group_id, bluetooth::Uuid uuid,
+               bluetooth::groups::DeviceGroupsCallbacks* group_callbacks, bool first_device) {
+              if (first_device) {
+                group_callbacks->OnGroupAdded(addr, uuid, group_id);
+              } else {
+                group_callbacks->OnGroupMemberAdded(addr, group_id);
+              }
+            },
+            address, group_id, uuid, base::Unretained(this->group_callbacks_), first_device));
   }
 
   void InjectServiceChangedEvent(const RawAddress& address, uint16_t conn_id) {
     tBTA_GATTC_SERVICE_CHANGED event_data = {.remote_bda = address, .conn_id = conn_id};
 
-    do_in_main_thread(
-            FROM_HERE,
-            base::BindOnce(
-                    [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_SERVICE_CHANGED event_data) {
-                      gatt_callback(BTA_GATTC_SRVC_CHG_EVT, (tBTA_GATTC*)&event_data);
-                    },
-                    base::Unretained(this->gatt_callback), event_data));
+    do_in_main_thread(base::BindOnce(
+            [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_SERVICE_CHANGED event_data) {
+              gatt_callback(BTA_GATTC_SRVC_CHG_EVT, (tBTA_GATTC*)&event_data);
+            },
+            base::Unretained(this->gatt_callback), event_data));
   }
 
   void InjectConnectedEvent(const RawAddress& address, uint16_t conn_id,
@@ -495,12 +489,11 @@ protected:
       peer_devices.at(conn_id)->connected = true;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(
-                              [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_OPEN event_data) {
-                                gatt_callback(BTA_GATTC_OPEN_EVT, (tBTA_GATTC*)&event_data);
-                              },
-                              base::Unretained(this->gatt_callback), event_data));
+    do_in_main_thread(base::BindOnce(
+            [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_OPEN event_data) {
+              gatt_callback(BTA_GATTC_OPEN_EVT, (tBTA_GATTC*)&event_data);
+            },
+            base::Unretained(this->gatt_callback), event_data));
   }
 
   void InjectEncryptionChangedEvent(const RawAddress& address) {
@@ -509,13 +502,11 @@ protected:
             .remote_bda = address,
     };
 
-    do_in_main_thread(
-            FROM_HERE,
-            base::BindOnce(
-                    [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_ENC_CMPL_CB event_data) {
-                      gatt_callback(BTA_GATTC_ENC_CMPL_CB_EVT, (tBTA_GATTC*)&event_data);
-                    },
-                    base::Unretained(this->gatt_callback), event_data));
+    do_in_main_thread(base::BindOnce(
+            [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_ENC_CMPL_CB event_data) {
+              gatt_callback(BTA_GATTC_ENC_CMPL_CB_EVT, (tBTA_GATTC*)&event_data);
+            },
+            base::Unretained(this->gatt_callback), event_data));
   }
 
   void InjectDisconnectedEvent(uint16_t conn_id,
@@ -532,12 +523,11 @@ protected:
     };
 
     peer_devices.at(conn_id)->connected = false;
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(
-                              [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_CLOSE event_data) {
-                                gatt_callback(BTA_GATTC_CLOSE_EVT, (tBTA_GATTC*)&event_data);
-                              },
-                              base::Unretained(this->gatt_callback), event_data));
+    do_in_main_thread(base::BindOnce(
+            [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_CLOSE event_data) {
+              gatt_callback(BTA_GATTC_CLOSE_EVT, (tBTA_GATTC*)&event_data);
+            },
+            base::Unretained(this->gatt_callback), event_data));
   }
 
   void InjectPhyChangedEvent(uint16_t conn_id, uint8_t tx_phy, uint8_t rx_phy,
@@ -550,13 +540,11 @@ protected:
             .status = status,
     };
 
-    do_in_main_thread(
-            FROM_HERE,
-            base::BindOnce(
-                    [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_PHY_UPDATE event_data) {
-                      gatt_callback(BTA_GATTC_PHY_UPDATE_EVT, (tBTA_GATTC*)&event_data);
-                    },
-                    base::Unretained(this->gatt_callback), event_data));
+    do_in_main_thread(base::BindOnce(
+            [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_PHY_UPDATE event_data) {
+              gatt_callback(BTA_GATTC_PHY_UPDATE_EVT, (tBTA_GATTC*)&event_data);
+            },
+            base::Unretained(this->gatt_callback), event_data));
   }
 
   void InjectSearchCompleteEvent(uint16_t conn_id) {
@@ -566,13 +554,11 @@ protected:
             .status = GATT_SUCCESS,
     };
 
-    do_in_main_thread(
-            FROM_HERE,
-            base::BindOnce(
-                    [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_SEARCH_CMPL event_data) {
-                      gatt_callback(BTA_GATTC_SEARCH_CMPL_EVT, (tBTA_GATTC*)&event_data);
-                    },
-                    base::Unretained(this->gatt_callback), event_data));
+    do_in_main_thread(base::BindOnce(
+            [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_SEARCH_CMPL event_data) {
+              gatt_callback(BTA_GATTC_SEARCH_CMPL_EVT, (tBTA_GATTC*)&event_data);
+            },
+            base::Unretained(this->gatt_callback), event_data));
   }
 
   void InjectNotificationEvent(const RawAddress& test_address, uint16_t conn_id, uint16_t handle,
@@ -587,12 +573,11 @@ protected:
     };
 
     std::copy(value.begin(), value.end(), event_data.value);
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(
-                              [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_NOTIFY event_data) {
-                                gatt_callback(BTA_GATTC_NOTIF_EVT, (tBTA_GATTC*)&event_data);
-                              },
-                              base::Unretained(this->gatt_callback), event_data));
+    do_in_main_thread(base::BindOnce(
+            [](tBTA_GATTC_CBACK* gatt_callback, tBTA_GATTC_NOTIFY event_data) {
+              gatt_callback(BTA_GATTC_NOTIF_EVT, (tBTA_GATTC*)&event_data);
+            },
+            base::Unretained(this->gatt_callback), event_data));
   }
 
   void InjectContextTypes(const RawAddress& test_address, uint16_t conn_id, uint16_t handle,
@@ -694,14 +679,12 @@ protected:
               }
 
               if (cb) {
-                do_in_main_thread(
-                        FROM_HERE,
-                        base::BindOnce(
-                                [](GATT_WRITE_OP_CB cb, uint16_t conn_id, uint16_t handle,
-                                   uint16_t len, uint8_t* value, void* cb_data) {
-                                  cb(conn_id, GATT_SUCCESS, handle, len, value, cb_data);
-                                },
-                                cb, conn_id, handle, value.size(), value.data(), cb_data));
+                do_in_main_thread(base::BindOnce(
+                        [](GATT_WRITE_OP_CB cb, uint16_t conn_id, uint16_t handle, uint16_t len,
+                           uint8_t* value, void* cb_data) {
+                          cb(conn_id, GATT_SUCCESS, handle, len, value, cb_data);
+                        },
+                        cb, conn_id, handle, value.size(), value.data(), cb_data));
               }
             }));
 
@@ -719,11 +702,9 @@ protected:
 
     // default Characteristic read handler dispatches requests to service mocks
     ON_CALL(mock_gatt_queue_, ReadCharacteristic(_, _, _, _))
-            .WillByDefault(Invoke([&](uint16_t conn_id, uint16_t handle, GATT_READ_OP_CB cb,
-                                      void* cb_data) {
-              do_in_main_thread(
-                      FROM_HERE,
-                      base::BindOnce(
+            .WillByDefault(Invoke(
+                    [&](uint16_t conn_id, uint16_t handle, GATT_READ_OP_CB cb, void* cb_data) {
+                      do_in_main_thread(base::BindOnce(
                               [](std::map<uint16_t, std::unique_ptr<NiceMock<MockDeviceWrapper>>>*
                                          peer_devices,
                                  uint16_t conn_id, uint16_t handle, GATT_READ_OP_CB cb,
@@ -753,7 +734,7 @@ protected:
                                 }
                               },
                               &peer_devices, conn_id, handle, cb, cb_data));
-            }));
+                    }));
   }
 
   void SetUpMockGroups() {
@@ -786,14 +767,12 @@ protected:
                 return;
               }
 
-              do_in_main_thread(
-                      FROM_HERE,
-                      base::BindOnce(
-                              [](const RawAddress& address, int group_id,
-                                 bluetooth::groups::DeviceGroupsCallbacks* group_callbacks) {
-                                group_callbacks->OnGroupMemberRemoved(address, group_id);
-                              },
-                              addr, group_id, base::Unretained(group_callbacks_)));
+              do_in_main_thread(base::BindOnce(
+                      [](const RawAddress& address, int group_id,
+                         bluetooth::groups::DeviceGroupsCallbacks* group_callbacks) {
+                        group_callbacks->OnGroupMemberRemoved(address, group_id);
+                      },
+                      addr, group_id, base::Unretained(group_callbacks_)));
             });
 
     // Our test devices have unique LSB - use it for unique grouping when
@@ -864,17 +843,14 @@ protected:
                               types::AseState::BTA_LE_AUDIO_ASE_STATE_CODEC_CONFIGURED);
                       group->SetState(group->GetTargetState());
                       group->ClearPendingConfiguration();
-                      do_in_main_thread(
-                              FROM_HERE,
-                              base::BindOnce(
-                                      [](int group_id,
-                                         bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                                                 state_machine_callbacks) {
-                                        state_machine_callbacks->StatusReportCb(
-                                                group_id, GroupStreamStatus::CONFIGURED_BY_USER);
-                                      },
-                                      group->group_id_,
-                                      base::Unretained(this->state_machine_callbacks_)));
+                      do_in_main_thread(base::BindOnce(
+                              [](int group_id,
+                                 bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
+                                         state_machine_callbacks) {
+                                state_machine_callbacks->StatusReportCb(
+                                        group_id, GroupStreamStatus::CONFIGURED_BY_USER);
+                              },
+                              group->group_id_, base::Unretained(this->state_machine_callbacks_)));
                       return true;
                     });
 
@@ -1167,16 +1143,13 @@ protected:
               }
 
               group->SetState(types::AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING);
-              do_in_main_thread(
-                      FROM_HERE,
-                      base::BindOnce(
-                              [](int group_id,
-                                 bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                                         state_machine_callbacks) {
-                                state_machine_callbacks->StatusReportCb(
-                                        group_id, GroupStreamStatus::STREAMING);
-                              },
-                              group->group_id_, base::Unretained(this->state_machine_callbacks_)));
+              do_in_main_thread(base::BindOnce(
+                      [](int group_id, bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
+                                               state_machine_callbacks) {
+                        state_machine_callbacks->StatusReportCb(group_id,
+                                                                GroupStreamStatus::STREAMING);
+                      },
+                      group->group_id_, base::Unretained(this->state_machine_callbacks_)));
               return true;
             });
 
@@ -1361,12 +1334,11 @@ protected:
       group->SetState(group->GetTargetState());
       state_machine_callbacks_->StatusReportCb(group->group_id_, GroupStreamStatus::RELEASING);
 
-      do_in_main_thread(
-              FROM_HERE,
-              base::BindOnce(
-                      [](bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* cb,
-                         int group_id) { cb->StatusReportCb(group_id, GroupStreamStatus::IDLE); },
-                      state_machine_callbacks_, group->group_id_));
+      do_in_main_thread(base::BindOnce(
+              [](bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* cb, int group_id) {
+                cb->StatusReportCb(group_id, GroupStreamStatus::IDLE);
+              },
+              state_machine_callbacks_, group->group_id_));
     });
   }
 
@@ -1646,8 +1618,8 @@ protected:
               .Times(1);
     }
 
-    do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::Connect,
-                                                base::Unretained(LeAudioClient::Get()), address));
+    do_in_main_thread(base::BindOnce(&LeAudioClient::Connect,
+                                     base::Unretained(LeAudioClient::Get()), address));
 
     SyncOnMainLoop();
     Mock::VerifyAndClearExpectations(&mock_btm_interface_);
@@ -1670,8 +1642,8 @@ protected:
     EXPECT_CALL(mock_btm_interface_, AclDisconnectFromHandle(conn_id, _)).Times(0);
     EXPECT_CALL(mock_gatt_interface_, Close(conn_id)).Times(1);
 
-    do_in_main_thread(FROM_HERE, base::Bind(&LeAudioClient::Disconnect,
-                                            base::Unretained(LeAudioClient::Get()), address));
+    do_in_main_thread(base::Bind(&LeAudioClient::Disconnect, base::Unretained(LeAudioClient::Get()),
+                                 address));
     SyncOnMainLoop();
     Mock::VerifyAndClearExpectations(&mock_btm_interface_);
     Mock::VerifyAndClearExpectations(&mock_gatt_interface_);
@@ -1695,8 +1667,8 @@ protected:
             });
     EXPECT_CALL(mock_gatt_interface_, Close(conn_id)).Times(0);
 
-    do_in_main_thread(FROM_HERE, base::Bind(&LeAudioClient::Disconnect,
-                                            base::Unretained(LeAudioClient::Get()), address));
+    do_in_main_thread(base::Bind(&LeAudioClient::Disconnect, base::Unretained(LeAudioClient::Get()),
+                                 address));
     SyncOnMainLoop();
     Mock::VerifyAndClearExpectations(&mock_btm_interface_);
     Mock::VerifyAndClearExpectations(&mock_gatt_interface_);
@@ -1706,8 +1678,8 @@ protected:
   void DisconnectLeAudioNoDisconnectedEvtExpected(const RawAddress& address, uint16_t conn_id) {
     EXPECT_CALL(mock_gatt_interface_, Close(conn_id)).Times(0);
     EXPECT_CALL(mock_btm_interface_, AclDisconnectFromHandle(conn_id, _)).Times(1);
-    do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::Disconnect,
-                                                base::Unretained(LeAudioClient::Get()), address));
+    do_in_main_thread(base::BindOnce(&LeAudioClient::Disconnect,
+                                     base::Unretained(LeAudioClient::Get()), address));
     SyncOnMainLoop();
     Mock::VerifyAndClearExpectations(&mock_gatt_interface_);
     Mock::VerifyAndClearExpectations(&mock_btm_interface_);
@@ -1736,8 +1708,7 @@ protected:
 
     if (connect_through_csis) {
       // Add it the way CSIS would do: add to group and then connect
-      do_in_main_thread(FROM_HERE,
-                        base::BindOnce(&LeAudioClient::GroupAddNode,
+      do_in_main_thread(base::BindOnce(&LeAudioClient::GroupAddNode,
                                        base::Unretained(LeAudioClient::Get()), group_id, addr));
       ConnectLeAudio(addr);
     } else {
@@ -1858,13 +1829,13 @@ protected:
       EXPECT_CALL(*mock_le_audio_source_hal_client_, CancelStreamingRequest()).Times(1);
     }
 
-    do_in_main_thread(FROM_HERE, base::BindOnce(
-                                         [](LeAudioSourceAudioHalClient::Callbacks* cb) {
-                                           if (cb) {
-                                             cb->OnAudioResume();
-                                           }
-                                         },
-                                         unicast_source_hal_cb_));
+    do_in_main_thread(base::BindOnce(
+            [](LeAudioSourceAudioHalClient::Callbacks* cb) {
+              if (cb) {
+                cb->OnAudioResume();
+              }
+            },
+            unicast_source_hal_cb_));
 
     SyncOnMainLoop();
     Mock::VerifyAndClearExpectations(&*mock_le_audio_source_hal_client_);
@@ -1879,7 +1850,6 @@ protected:
   void LocalAudioSinkResume(void) {
     ASSERT_NE(unicast_sink_hal_cb_, nullptr);
     do_in_main_thread(
-            FROM_HERE,
             base::BindOnce([](LeAudioSinkAudioHalClient::Callbacks* cb) { cb->OnAudioResume(); },
                            unicast_sink_hal_cb_));
 
@@ -1910,7 +1880,6 @@ protected:
     if (usage == AUDIO_USAGE_VOICE_COMMUNICATION || audio_source != AUDIO_SOURCE_INVALID) {
       ASSERT_NE(unicast_sink_hal_cb_, nullptr);
       do_in_main_thread(
-              FROM_HERE,
               base::BindOnce([](LeAudioSinkAudioHalClient::Callbacks* cb) { cb->OnAudioResume(); },
                              unicast_sink_hal_cb_));
     }
@@ -3227,8 +3196,7 @@ TEST_F(UnicastTest, DisconnectWhenLinkKeyIsGone) {
           .WillByDefault(Return(BTM_ERR_KEY_MISSING));
 
   EXPECT_CALL(mock_gatt_interface_, Close(conn_id)).Times(1);
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&LeAudioClient::Connect, base::Unretained(LeAudioClient::Get()),
+  do_in_main_thread(base::BindOnce(&LeAudioClient::Connect, base::Unretained(LeAudioClient::Get()),
                                    test_address0));
 
   SyncOnMainLoop();
@@ -3433,17 +3401,16 @@ TEST_F(UnicastTestNoInit, ConnectFailedDueToInvalidParameters) {
   LeAudioClient::GetSinkPacsForStorage(test_address0, snk_pacs);
 
   EXPECT_CALL(mock_storage_load, Call()).WillOnce([&]() {
-    do_in_main_thread(FROM_HERE, base::Bind(&LeAudioClient::AddFromStorage, test_address0,
-                                            autoconnect, codec_spec_conf::kLeAudioLocationFrontLeft,
-                                            codec_spec_conf::kLeAudioLocationFrontLeft, 0xff, 0xff,
-                                            std::move(handles), std::move(snk_pacs),
-                                            std::move(src_pacs), std::move(ases)));
-    do_in_main_thread(
-            FROM_HERE,
-            base::Bind(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
-                       codec_spec_conf::kLeAudioLocationFrontRight,
-                       codec_spec_conf::kLeAudioLocationFrontRight, 0xff, 0xff, std::move(handles),
-                       std::move(snk_pacs), std::move(src_pacs), std::move(ases)));
+    do_in_main_thread(base::Bind(&LeAudioClient::AddFromStorage, test_address0, autoconnect,
+                                 codec_spec_conf::kLeAudioLocationFrontLeft,
+                                 codec_spec_conf::kLeAudioLocationFrontLeft, 0xff, 0xff,
+                                 std::move(handles), std::move(snk_pacs), std::move(src_pacs),
+                                 std::move(ases)));
+    do_in_main_thread(base::Bind(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
+                                 codec_spec_conf::kLeAudioLocationFrontRight,
+                                 codec_spec_conf::kLeAudioLocationFrontRight, 0xff, 0xff,
+                                 std::move(handles), std::move(snk_pacs), std::move(src_pacs),
+                                 std::move(ases)));
   });
 
   // Expect stored device0 to connect automatically (first directed connection )
@@ -3540,14 +3507,12 @@ TEST_F(UnicastTestNoInit, LoadStoredEarbudsBroakenStorage) {
   std::vector<uint8_t> empty_buf;
 
   EXPECT_CALL(mock_storage_load, Call()).WillOnce([&]() {
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect,
                                      codec_spec_conf::kLeAudioLocationFrontLeft,
                                      codec_spec_conf::kLeAudioLocationFrontLeft, 0xff, 0xff,
                                      std::move(empty_buf), std::move(empty_buf),
                                      std::move(empty_buf), std::move(empty_buf)));
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
                                      codec_spec_conf::kLeAudioLocationFrontRight,
                                      codec_spec_conf::kLeAudioLocationFrontRight, 0xff, 0xff,
                                      std::move(empty_buf), std::move(empty_buf),
@@ -3683,14 +3648,12 @@ TEST_F(UnicastTestNoInit, LoadStoredEarbudsCsisGrouped) {
   LeAudioClient::GetSinkPacsForStorage(test_address0, snk_pacs);
 
   EXPECT_CALL(mock_storage_load, Call()).WillOnce([&]() {
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect,
                                      codec_spec_conf::kLeAudioLocationFrontLeft,
                                      codec_spec_conf::kLeAudioLocationFrontLeft, 0xff, 0xff,
                                      std::move(handles), std::move(snk_pacs), std::move(src_pacs),
                                      std::move(ases)));
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
                                      codec_spec_conf::kLeAudioLocationFrontRight,
                                      codec_spec_conf::kLeAudioLocationFrontRight, 0xff, 0xff,
                                      std::move(handles), std::move(snk_pacs), std::move(src_pacs),
@@ -3822,14 +3785,12 @@ TEST_F(UnicastTestNoInit, ServiceChangedBeforeServiceIsConnected) {
   LeAudioClient::GetSinkPacsForStorage(test_address0, snk_pacs);
 
   EXPECT_CALL(mock_storage_load, Call()).WillOnce([&]() {
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect,
                                      codec_spec_conf::kLeAudioLocationFrontLeft,
                                      codec_spec_conf::kLeAudioLocationFrontLeft, 0xff, 0xff,
                                      std::move(handles), std::move(snk_pacs), std::move(src_pacs),
                                      std::move(ases)));
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect,
                                      codec_spec_conf::kLeAudioLocationFrontRight,
                                      codec_spec_conf::kLeAudioLocationFrontRight, 0xff, 0xff,
                                      std::move(handles), std::move(snk_pacs), std::move(src_pacs),
@@ -3951,14 +3912,12 @@ TEST_F(UnicastTestNoInit, LoadStoredEarbudsCsisGroupedDifferently) {
 
   // Load devices from the storage when storage API is called
   EXPECT_CALL(mock_storage_load, Call()).WillOnce([&]() {
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect0,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address0, autoconnect0,
                                      codec_spec_conf::kLeAudioLocationFrontLeft,
                                      codec_spec_conf::kLeAudioLocationFrontLeft, 0xff, 0xff,
                                      std::move(handles), std::move(snk_pacs), std::move(src_pacs),
                                      std::move(ases)));
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect1,
+    do_in_main_thread(base::BindOnce(&LeAudioClient::AddFromStorage, test_address1, autoconnect1,
                                      codec_spec_conf::kLeAudioLocationFrontRight,
                                      codec_spec_conf::kLeAudioLocationFrontRight, 0xff, 0xff,
                                      std::move(handles), std::move(snk_pacs), std::move(src_pacs),
@@ -4165,14 +4124,12 @@ TEST_F(UnicastTest, DoubleResumeFromAF) {
 
   EXPECT_CALL(mock_state_machine_, StopStream(_)).Times(0);
 
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  [](int group_id, bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                                           state_machine_callbacks) {
-                    state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
-                  },
-                  group_id, base::Unretained(state_machine_callbacks_)));
+  do_in_main_thread(base::BindOnce(
+          [](int group_id,
+             bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* state_machine_callbacks) {
+            state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
+          },
+          group_id, base::Unretained(state_machine_callbacks_)));
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_state_machine_);
 
@@ -4227,14 +4184,12 @@ TEST_F(UnicastTest, DoubleResumeFromAFOnLocalSink) {
 
   EXPECT_CALL(mock_state_machine_, StopStream(_)).Times(0);
 
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  [](int group_id, bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                                           state_machine_callbacks) {
-                    state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
-                  },
-                  group_id, base::Unretained(state_machine_callbacks_)));
+  do_in_main_thread(base::BindOnce(
+          [](int group_id,
+             bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* state_machine_callbacks) {
+            state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
+          },
+          group_id, base::Unretained(state_machine_callbacks_)));
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_state_machine_);
 
@@ -4670,16 +4625,13 @@ TEST_F(UnicastTest, TestUpdateConfigurationCallbackWhileStreaming) {
 
   // Inject STREAMING Status from state machine.
   auto group = streaming_groups.at(group_id);
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  [](int group_id,
-                     bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                             state_machine_callbacks,
-                     LeAudioDeviceGroup* group) {
-                    state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
-                  },
-                  group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
+  do_in_main_thread(base::BindOnce(
+          [](int group_id,
+             bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* state_machine_callbacks,
+             LeAudioDeviceGroup* group) {
+            state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
+          },
+          group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
 
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_state_machine_);
@@ -4712,16 +4664,13 @@ TEST_F(UnicastTest, TestDeactivateWhileStartingStream) {
 
   // Inject STREAMING Status from state machine.
   auto group = streaming_groups.at(group_id);
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  [](int group_id,
-                     bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                             state_machine_callbacks,
-                     LeAudioDeviceGroup* group) {
-                    state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
-                  },
-                  group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
+  do_in_main_thread(base::BindOnce(
+          [](int group_id,
+             bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* state_machine_callbacks,
+             LeAudioDeviceGroup* group) {
+            state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
+          },
+          group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
   SyncOnMainLoop();
 }
 
@@ -5005,8 +4954,8 @@ TEST_F(UnicastTest, RemoveTwoEarbudsCsisGrouped) {
   EXPECT_CALL(mock_btm_interface_, AclDisconnectFromHandle(3, _)).Times(0);
   EXPECT_CALL(mock_btm_interface_, AclDisconnectFromHandle(4, _)).Times(0);
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::GroupDestroy,
-                                              base::Unretained(LeAudioClient::Get()), group_id0));
+  do_in_main_thread(base::BindOnce(&LeAudioClient::GroupDestroy,
+                                   base::Unretained(LeAudioClient::Get()), group_id0));
 
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_btif_storage_);
@@ -5028,17 +4977,16 @@ TEST_F(UnicastTest, ConnectAfterRemove) {
           .Times(1);
 
   /* RemoveDevice */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address0) {
-                                         client->RemoveDevice(test_address0);
-                                       },
-                                       LeAudioClient::Get(), test_address0));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client, const RawAddress& test_address0) {
+            client->RemoveDevice(test_address0);
+          },
+          LeAudioClient::Get(), test_address0));
   SyncOnMainLoop();
 
   ON_CALL(mock_btm_interface_, IsLinkKeyKnown(_, _)).WillByDefault(DoAll(Return(false)));
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&LeAudioClient::Connect, base::Unretained(LeAudioClient::Get()),
+  do_in_main_thread(base::BindOnce(&LeAudioClient::Connect, base::Unretained(LeAudioClient::Get()),
                                    test_address0));
   SyncOnMainLoop();
 
@@ -5079,11 +5027,11 @@ TEST_F(UnicastTest, RemoveDeviceWhenConnected) {
    * of operations and to avoid races we put the test command on main_loop as
    * well.
    */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address0) {
-                                         client->RemoveDevice(test_address0);
-                                       },
-                                       LeAudioClient::Get(), test_address0));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client, const RawAddress& test_address0) {
+            client->RemoveDevice(test_address0);
+          },
+          LeAudioClient::Get(), test_address0));
   SyncOnMainLoop();
 
   Mock::VerifyAndClearExpectations(&mock_btif_storage_);
@@ -5121,11 +5069,11 @@ TEST_F(UnicastTest, RemoveDeviceWhenConnecting) {
    * of operations and to avoid races we put the test command on main_loop as
    * well.
    */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address0) {
-                                         client->RemoveDevice(test_address0);
-                                       },
-                                       LeAudioClient::Get(), test_address0));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client, const RawAddress& test_address0) {
+            client->RemoveDevice(test_address0);
+          },
+          LeAudioClient::Get(), test_address0));
 
   SyncOnMainLoop();
 
@@ -5165,11 +5113,11 @@ TEST_F(UnicastTest, RemoveDeviceWhenGettingConnectionReady) {
    * of operations and to avoid races we put the test command on main_loop as
    * well.
    */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address0) {
-                                         client->RemoveDevice(test_address0);
-                                       },
-                                       LeAudioClient::Get(), test_address0));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client, const RawAddress& test_address0) {
+            client->RemoveDevice(test_address0);
+          },
+          LeAudioClient::Get(), test_address0));
 
   SyncOnMainLoop();
 
@@ -5347,11 +5295,11 @@ TEST_F(UnicastTest, RemoveWhileStreaming) {
    * of operations and to avoid races we put the test command on main_loop as
    * well.
    */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address0) {
-                                         client->RemoveDevice(test_address0);
-                                       },
-                                       LeAudioClient::Get(), test_address0));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client, const RawAddress& test_address0) {
+            client->RemoveDevice(test_address0);
+          },
+          LeAudioClient::Get(), test_address0));
 
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_groups_module_);
@@ -5427,11 +5375,10 @@ TEST_F(UnicastTest, DisconnecteWhileAlmostStreaming) {
    * of operations and to avoid races we put the test command on main_loop as
    * well.
    */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address0) {
-                                         client->Disconnect(test_address0);
-                                       },
-                                       LeAudioClient::Get(), test_address0));
+  do_in_main_thread(
+          base::BindOnce([](LeAudioClient* client,
+                            const RawAddress& test_address0) { client->Disconnect(test_address0); },
+                         LeAudioClient::Get(), test_address0));
 
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_groups_module_);
@@ -6699,18 +6646,15 @@ TEST_F(UnicastTest, LateStreamConnectBasedOnContextType) {
 
   // Now simulate group is finally streaming
   auto group = streaming_groups.at(group_id);
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  [](int group_id,
-                     bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                             state_machine_callbacks,
-                     LeAudioDeviceGroup* group) {
-                    group->SetState(types::AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING);
+  do_in_main_thread(base::BindOnce(
+          [](int group_id,
+             bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* state_machine_callbacks,
+             LeAudioDeviceGroup* group) {
+            group->SetState(types::AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING);
 
-                    state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
-                  },
-                  group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
+            state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
+          },
+          group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
 
   SyncOnMainLoop();
 
@@ -6776,18 +6720,15 @@ TEST_F(UnicastTest, CheckDeviceIsNotAttachedToStreamWhenNotNeeded) {
 
   // Now simulate group is finally streaming
   auto group = streaming_groups.at(group_id);
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  [](int group_id,
-                     bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                             state_machine_callbacks,
-                     LeAudioDeviceGroup* group) {
-                    group->SetState(types::AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING);
+  do_in_main_thread(base::BindOnce(
+          [](int group_id,
+             bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* state_machine_callbacks,
+             LeAudioDeviceGroup* group) {
+            group->SetState(types::AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING);
 
-                    state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
-                  },
-                  group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
+            state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
+          },
+          group_id, base::Unretained(this->state_machine_callbacks_), std::move(group)));
 
   SyncOnMainLoop();
 
@@ -7610,10 +7551,10 @@ TEST_F(UnicastTest, TwoEarbudsStreamingProfileDisconnectStreamStopTimeout) {
   EXPECT_CALL(mock_gatt_interface_, Close(_)).Times(0);
   EXPECT_CALL(mock_btm_interface_, AclDisconnectFromHandle(_, _)).Times(0);
 
-  do_in_main_thread(FROM_HERE, base::Bind(&LeAudioClient::Disconnect,
-                                          base::Unretained(LeAudioClient::Get()), test_address0));
-  do_in_main_thread(FROM_HERE, base::Bind(&LeAudioClient::Disconnect,
-                                          base::Unretained(LeAudioClient::Get()), test_address1));
+  do_in_main_thread(base::Bind(&LeAudioClient::Disconnect, base::Unretained(LeAudioClient::Get()),
+                               test_address0));
+  do_in_main_thread(base::Bind(&LeAudioClient::Disconnect, base::Unretained(LeAudioClient::Get()),
+                               test_address1));
 
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_gatt_interface_);
@@ -7760,7 +7701,6 @@ TEST_F(UnicastTest, MicrophoneAttachToCurrentMediaScenario) {
   // Resume on local audio sink
   ASSERT_NE(unicast_sink_hal_cb_, nullptr);
   do_in_main_thread(
-          FROM_HERE,
           base::BindOnce([](LeAudioSinkAudioHalClient::Callbacks* cb) { cb->OnAudioResume(); },
                          unicast_sink_hal_cb_));
 
@@ -7773,7 +7713,6 @@ TEST_F(UnicastTest, MicrophoneAttachToCurrentMediaScenario) {
 
   LocalAudioSourceResume();
   do_in_main_thread(
-          FROM_HERE,
           base::BindOnce([](LeAudioSinkAudioHalClient::Callbacks* cb) { cb->OnAudioResume(); },
                          unicast_sink_hal_cb_));
   SyncOnMainLoop();
@@ -7791,11 +7730,9 @@ TEST_F(UnicastTest, MicrophoneAttachToCurrentMediaScenario) {
   EXPECT_CALL(*mock_le_audio_source_hal_client_, Stop()).Times(1);
   EXPECT_CALL(*mock_le_audio_source_hal_client_, OnDestroyed()).Times(1);
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, OnDestroyed()).Times(1);
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client) {
-                                         client->GroupSetActive(bluetooth::groups::kGroupUnknown);
-                                       },
-                                       LeAudioClient::Get()));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client) { client->GroupSetActive(bluetooth::groups::kGroupUnknown); },
+          LeAudioClient::Get()));
   SyncOnMainLoop();
 
   Mock::VerifyAndClearExpectations(mock_le_audio_source_hal_client_);
@@ -8007,11 +7944,9 @@ TEST_F(UnicastTest, UpdateMultipleBidirContextTypes) {
   EXPECT_CALL(*mock_le_audio_source_hal_client_, Stop()).Times(1);
   EXPECT_CALL(*mock_le_audio_source_hal_client_, OnDestroyed()).Times(1);
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, OnDestroyed()).Times(1);
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client) {
-                                         client->GroupSetActive(bluetooth::groups::kGroupUnknown);
-                                       },
-                                       LeAudioClient::Get()));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client) { client->GroupSetActive(bluetooth::groups::kGroupUnknown); },
+          LeAudioClient::Get()));
   SyncOnMainLoop();
 }
 
@@ -8221,11 +8156,9 @@ TEST_F(UnicastTest, MusicDuringCallContextTypes) {
   EXPECT_CALL(*mock_le_audio_source_hal_client_, Stop()).Times(1);
   EXPECT_CALL(*mock_le_audio_source_hal_client_, OnDestroyed()).Times(1);
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, OnDestroyed()).Times(1);
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client) {
-                                         client->GroupSetActive(bluetooth::groups::kGroupUnknown);
-                                       },
-                                       LeAudioClient::Get()));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client) { client->GroupSetActive(bluetooth::groups::kGroupUnknown); },
+          LeAudioClient::Get()));
   SyncOnMainLoop();
 }
 
@@ -8454,11 +8387,9 @@ TEST_F(UnicastTest, NotifyAboutGroupTunrnedIdleEnabled) {
   EXPECT_CALL(*mock_le_audio_source_hal_client_, OnDestroyed()).Times(1);
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, OnDestroyed()).Times(1);
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client) {
-                                         client->GroupSetActive(bluetooth::groups::kGroupUnknown);
-                                       },
-                                       LeAudioClient::Get()));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client) { client->GroupSetActive(bluetooth::groups::kGroupUnknown); },
+          LeAudioClient::Get()));
 
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(mock_le_audio_source_hal_client_);
@@ -8518,11 +8449,9 @@ TEST_F(UnicastTest, NotifyAboutGroupTunrnedIdleDisabled) {
   EXPECT_CALL(*mock_le_audio_source_hal_client_, OnDestroyed()).Times(1);
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, OnDestroyed()).Times(1);
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client) {
-                                         client->GroupSetActive(bluetooth::groups::kGroupUnknown);
-                                       },
-                                       LeAudioClient::Get()));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client) { client->GroupSetActive(bluetooth::groups::kGroupUnknown); },
+          LeAudioClient::Get()));
 
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(mock_le_audio_source_hal_client_);
@@ -8882,8 +8811,7 @@ TEST_F(UnicastTest, DisconnectAclBeforeGettingReadResponses) {
               Open(gatt_if, test_address0, BTM_BLE_BKG_CONNECT_TARGETED_ANNOUNCEMENTS, _))
           .Times(1);
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&LeAudioClient::Connect, base::Unretained(LeAudioClient::Get()),
+  do_in_main_thread(base::BindOnce(&LeAudioClient::Connect, base::Unretained(LeAudioClient::Get()),
                                    test_address0));
 
   SyncOnMainLoop();
@@ -9173,11 +9101,11 @@ TEST_F_WITH_FLAGS(UnicastTest, GroupStreamStatusResendAfterRemove,
    * of operations and to avoid races we put the test command on main_loop as
    * well.
    */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address0) {
-                                         client->RemoveDevice(test_address0);
-                                       },
-                                       LeAudioClient::Get(), test_address0));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client, const RawAddress& test_address0) {
+            client->RemoveDevice(test_address0);
+          },
+          LeAudioClient::Get(), test_address0));
   SyncOnMainLoop();
   EXPECT_CALL(mock_audio_hal_client_callbacks_,
               OnGroupStreamStatus(group_id, GroupStreamStatus::IDLE))
@@ -9191,11 +9119,11 @@ TEST_F_WITH_FLAGS(UnicastTest, GroupStreamStatusResendAfterRemove,
    * of operations and to avoid races we put the test command on main_loop as
    * well.
    */
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](LeAudioClient* client, const RawAddress& test_address1) {
-                                         client->RemoveDevice(test_address1);
-                                       },
-                                       LeAudioClient::Get(), test_address1));
+  do_in_main_thread(base::BindOnce(
+          [](LeAudioClient* client, const RawAddress& test_address1) {
+            client->RemoveDevice(test_address1);
+          },
+          LeAudioClient::Get(), test_address1));
   SyncOnMainLoop();
   EXPECT_CALL(mock_audio_hal_client_callbacks_,
               OnGroupStreamStatus(group_id, GroupStreamStatus::IDLE))
@@ -9249,10 +9177,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetSinkMonitorModeWhileUnicastIsActiv
   TestAudioDataTransfer(group_id, cis_count_out, cis_count_in, 1920, 40);
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, true /* enable */));
 
   ASSERT_NE(0lu, streaming_groups.count(group_id));
   auto group = streaming_groups.at(group_id);
@@ -9341,10 +9268,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetSinkMonitorModeWhileUnicastIsActiv
   // De-activate monitoring mode
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, Stop()).Times(1);
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, OnDestroyed()).Times(1);
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              false /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, false /* enable */));
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(mock_le_audio_sink_hal_client_);
 }
@@ -9356,10 +9282,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetSinkMonitorModeWhileUnicastIsInact
   int group_id = 2;
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, true /* enable */));
 
   // Report working CSIS
   ON_CALL(mock_csis_client_module_, IsCsisClientRunning()).WillByDefault(Return(true));
@@ -9453,10 +9378,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, ClearSinkMonitorModeWhileUnicastIsAct
   int group_id = 2;
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, true /* enable */));
 
   // Report working CSIS
   ON_CALL(mock_csis_client_module_, IsCsisClientRunning()).WillByDefault(Return(true));
@@ -9506,10 +9430,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, ClearSinkMonitorModeWhileUnicastIsAct
   auto group = streaming_groups.at(group_id);
 
   // De-activate monitoring mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              false /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, false /* enable */));
 
   // Stop
   StopStreaming(group_id, true);
@@ -9554,14 +9477,12 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetAndClearSinkMonitorModeWhileUnicas
   EXPECT_CALL(*mock_le_audio_sink_hal_client_, OnDestroyed()).Times(0);
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              true /* enable */));
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              false /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, false /* enable */));
 
   SyncOnMainLoop();
 
@@ -9581,10 +9502,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetSourceMonitorModeWhileUnicastIsIna
           .Times(1);
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSource,
-                                              true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSource, true /* enable */));
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_audio_hal_client_callbacks_);
 }
@@ -9605,10 +9525,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetSourceMonitorModeWhileUnicastIsNot
           .Times(1);
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSource,
-                                              true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSource, true /* enable */));
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_audio_hal_client_callbacks_);
 }
@@ -9664,10 +9583,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetSourceMonitorModeWhileUnicastIsAct
           .Times(1);
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSource,
-                                              true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSource, true /* enable */));
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_audio_hal_client_callbacks_);
 
@@ -9759,10 +9677,9 @@ TEST_F_WITH_FLAGS(UnicastTestHandoverMode, SetSourceMonitorModeWhileUnicastIsAct
                                          UnicastMonitorModeStatus::STREAMING_SUSPENDED))
           .Times(0);
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSink,
-                                              false /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSink, false /* enable */));
 }
 
 TEST_F(UnicastTestHandoverMode, SetAllowedContextMask) {
@@ -9861,10 +9778,9 @@ TEST_F_WITH_FLAGS(UnicastTest, NoContextvalidateStreamingRequest,
   LeAudioClient::Get()->GroupSetActive(group_id);
 
   // Imitate activation of monitor mode
-  do_in_main_thread(FROM_HERE, base::BindOnce(&LeAudioClient::SetUnicastMonitorMode,
-                                              base::Unretained(LeAudioClient::Get()),
-                                              bluetooth::le_audio::types::kLeAudioDirectionSource,
-                                              true /* enable */));
+  do_in_main_thread(base::BindOnce(
+          &LeAudioClient::SetUnicastMonitorMode, base::Unretained(LeAudioClient::Get()),
+          bluetooth::le_audio::types::kLeAudioDirectionSource, true /* enable */));
   Mock::VerifyAndClearExpectations(&mock_audio_hal_client_callbacks_);
   SyncOnMainLoop();
 
@@ -10030,14 +9946,12 @@ TEST_F(UnicastTest, CodecFrameBlocks2) {
             remote_params.max_supported_codec_frames_per_sdu);
 
   EXPECT_CALL(mock_state_machine_, StopStream(_)).Times(0);
-  do_in_main_thread(
-          FROM_HERE,
-          base::BindOnce(
-                  [](int group_id, bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks*
-                                           state_machine_callbacks) {
-                    state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
-                  },
-                  group_id, base::Unretained(state_machine_callbacks_)));
+  do_in_main_thread(base::BindOnce(
+          [](int group_id,
+             bluetooth::le_audio::LeAudioGroupStateMachine::Callbacks* state_machine_callbacks) {
+            state_machine_callbacks->StatusReportCb(group_id, GroupStreamStatus::STREAMING);
+          },
+          group_id, base::Unretained(state_machine_callbacks_)));
   SyncOnMainLoop();
   Mock::VerifyAndClearExpectations(&mock_state_machine_);
 
diff --git a/system/bta/sdp/bta_sdp_api.cc b/system/bta/sdp/bta_sdp_api.cc
index cec89c358a..2944dd1254 100644
--- a/system/bta/sdp/bta_sdp_api.cc
+++ b/system/bta/sdp/bta_sdp_api.cc
@@ -57,7 +57,7 @@ tBTA_SDP_STATUS BTA_SdpEnable(tBTA_SDP_DM_CBACK* p_cback) {
   }
 
   memset(&bta_sdp_cb, 0, sizeof(tBTA_SDP_CB));
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_sdp_enable, p_cback));
+  do_in_main_thread(base::BindOnce(bta_sdp_enable, p_cback));
   return BTA_SDP_SUCCESS;
 }
 
@@ -75,7 +75,7 @@ tBTA_SDP_STATUS BTA_SdpEnable(tBTA_SDP_DM_CBACK* p_cback) {
  *
  ******************************************************************************/
 tBTA_SDP_STATUS BTA_SdpSearch(const RawAddress& bd_addr, const bluetooth::Uuid& uuid) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_sdp_search, bd_addr, uuid));
+  do_in_main_thread(base::BindOnce(bta_sdp_search, bd_addr, uuid));
   return BTA_SDP_SUCCESS;
 }
 
@@ -92,7 +92,7 @@ tBTA_SDP_STATUS BTA_SdpSearch(const RawAddress& bd_addr, const bluetooth::Uuid&
  *
  ******************************************************************************/
 tBTA_SDP_STATUS BTA_SdpCreateRecordByUser(void* user_data) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_sdp_create_record, user_data));
+  do_in_main_thread(base::BindOnce(bta_sdp_create_record, user_data));
   return BTA_SDP_SUCCESS;
 }
 
@@ -109,6 +109,6 @@ tBTA_SDP_STATUS BTA_SdpCreateRecordByUser(void* user_data) {
  *
  ******************************************************************************/
 tBTA_SDP_STATUS BTA_SdpRemoveRecordByUser(void* user_data) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_sdp_remove_record, user_data));
+  do_in_main_thread(base::BindOnce(bta_sdp_remove_record, user_data));
   return BTA_SDP_SUCCESS;
 }
diff --git a/system/bta/sys/bta_sys_main.cc b/system/bta/sys/bta_sys_main.cc
index 5229f3d365..4e5ad74d52 100644
--- a/system/bta/sys/bta_sys_main.cc
+++ b/system/bta/sys/bta_sys_main.cc
@@ -145,16 +145,14 @@ bool bta_sys_is_register(uint8_t id) { return bta_sys_cb.is_reg[id]; }
  *
  ******************************************************************************/
 void bta_sys_sendmsg(void* p_msg) {
-  if (do_in_main_thread(FROM_HERE,
-                        base::BindOnce(&bta_sys_event, static_cast<BT_HDR_RIGID*>(p_msg))) !=
+  if (do_in_main_thread(base::BindOnce(&bta_sys_event, static_cast<BT_HDR_RIGID*>(p_msg))) !=
       BT_STATUS_SUCCESS) {
     log::error("do_in_main_thread failed");
   }
 }
 
 void bta_sys_sendmsg_delayed(void* p_msg, std::chrono::microseconds delay) {
-  if (do_in_main_thread_delayed(FROM_HERE,
-                                base::Bind(&bta_sys_event, static_cast<BT_HDR_RIGID*>(p_msg)),
+  if (do_in_main_thread_delayed(base::Bind(&bta_sys_event, static_cast<BT_HDR_RIGID*>(p_msg)),
                                 delay) != BT_STATUS_SUCCESS) {
     log::error("do_in_main_thread_delayed failed");
   }
diff --git a/system/btif/avrcp/avrcp_service.cc b/system/btif/avrcp/avrcp_service.cc
index b968b6f930..77cb6bb5d5 100644
--- a/system/btif/avrcp/avrcp_service.cc
+++ b/system/btif/avrcp/avrcp_service.cc
@@ -156,7 +156,7 @@ public:
 
   void GetSongInfo(SongInfoCallback info_cb) override {
     auto cb_lambda = [](SongInfoCallback cb, SongInfo data) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, data));
+      do_in_main_thread(base::BindOnce(cb, data));
     };
 
     auto bound_cb = base::Bind(cb_lambda, info_cb);
@@ -167,7 +167,7 @@ public:
 
   void GetPlayStatus(PlayStatusCallback status_cb) override {
     auto cb_lambda = [](PlayStatusCallback cb, PlayStatus status) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, status));
+      do_in_main_thread(base::BindOnce(cb, status));
     };
 
     auto bound_cb = base::Bind(cb_lambda, status_cb);
@@ -179,7 +179,7 @@ public:
   void GetNowPlayingList(NowPlayingCallback now_playing_cb) override {
     auto cb_lambda = [](NowPlayingCallback cb, std::string curr_media_id,
                         std::vector<SongInfo> song_list) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, curr_media_id, std::move(song_list)));
+      do_in_main_thread(base::BindOnce(cb, curr_media_id, std::move(song_list)));
     };
 
     auto bound_cb = base::Bind(cb_lambda, now_playing_cb);
@@ -191,7 +191,7 @@ public:
   void GetMediaPlayerList(MediaListCallback list_cb) override {
     auto cb_lambda = [](MediaListCallback cb, uint16_t curr_player,
                         std::vector<MediaPlayerInfo> player_list) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, curr_player, std::move(player_list)));
+      do_in_main_thread(base::BindOnce(cb, curr_player, std::move(player_list)));
     };
 
     auto bound_cb = base::Bind(cb_lambda, list_cb);
@@ -203,7 +203,7 @@ public:
   void GetFolderItems(uint16_t player_id, std::string media_id,
                       FolderItemsCallback folder_cb) override {
     auto cb_lambda = [](FolderItemsCallback cb, std::vector<ListItem> item_list) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, std::move(item_list)));
+      do_in_main_thread(base::BindOnce(cb, std::move(item_list)));
     };
 
     auto bound_cb = base::Bind(cb_lambda, folder_cb);
@@ -215,7 +215,7 @@ public:
   void SetBrowsedPlayer(uint16_t player_id, SetBrowsedPlayerCallback browse_cb) override {
     auto cb_lambda = [](SetBrowsedPlayerCallback cb, bool success, std::string root_id,
                         uint32_t num_items) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, success, root_id, num_items));
+      do_in_main_thread(base::BindOnce(cb, success, root_id, num_items));
     };
 
     auto bound_cb = base::Bind(cb_lambda, browse_cb);
@@ -260,7 +260,7 @@ public:
 
   void DeviceConnected(const RawAddress& bdaddr, VolumeChangedCb cb) override {
     auto cb_lambda = [](VolumeChangedCb cb, int8_t volume) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, volume));
+      do_in_main_thread(base::BindOnce(cb, volume));
     };
 
     auto bound_cb = base::Bind(cb_lambda, cb);
@@ -293,7 +293,7 @@ public:
   void ListPlayerSettings(ListPlayerSettingsCallback cb) override {
     auto cb_lambda = [](const ListPlayerSettingsCallback& cb,
                         std::vector<PlayerAttribute> attributes) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, std::move(attributes)));
+      do_in_main_thread(base::BindOnce(cb, std::move(attributes)));
     };
 
     auto bound_cb = base::Bind(cb_lambda, cb);
@@ -306,7 +306,7 @@ public:
                                ListPlayerSettingValuesCallback cb) override {
     auto cb_lambda = [](const ListPlayerSettingValuesCallback& cb, PlayerAttribute setting,
                         std::vector<uint8_t> values) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, setting, std::move(values)));
+      do_in_main_thread(base::BindOnce(cb, setting, std::move(values)));
     };
 
     auto bound_cb = base::Bind(cb_lambda, cb);
@@ -319,7 +319,7 @@ public:
                                     GetCurrentPlayerSettingValueCallback cb) override {
     auto cb_lambda = [](const GetCurrentPlayerSettingValueCallback& cb,
                         std::vector<PlayerAttribute> attributes, std::vector<uint8_t> values) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, std::move(attributes), std::move(values)));
+      do_in_main_thread(base::BindOnce(cb, std::move(attributes), std::move(values)));
     };
 
     auto bound_cb = base::Bind(cb_lambda, cb);
@@ -331,7 +331,7 @@ public:
   void SetPlayerSettings(std::vector<PlayerAttribute> attributes, std::vector<uint8_t> values,
                          SetPlayerSettingValueCallback cb) override {
     auto cb_lambda = [](const SetPlayerSettingValueCallback& cb, bool success) {
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, success));
+      do_in_main_thread(base::BindOnce(cb, success));
     };
 
     auto bound_cb = base::Bind(cb_lambda, cb);
@@ -478,8 +478,8 @@ void AvrcpService::SendMediaUpdate(bool track_changed, bool play_state, bool que
   // This function may be called on any thread, we need to make sure that the
   // device update happens on the main thread.
   for (const auto& device : instance_->connection_handler_->GetListOfDevices()) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&Device::SendMediaUpdate, device.get()->Get(),
-                                                track_changed, play_state, queue));
+    do_in_main_thread(base::BindOnce(&Device::SendMediaUpdate, device.get()->Get(), track_changed,
+                                     play_state, queue));
   }
 }
 
@@ -489,8 +489,8 @@ void AvrcpService::SendFolderUpdate(bool available_players, bool addressed_playe
 
   // Ensure that the update is posted to the correct thread
   for (const auto& device : instance_->connection_handler_->GetListOfDevices()) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&Device::SendFolderUpdate, device.get()->Get(),
-                                                available_players, addressed_players, uids));
+    do_in_main_thread(base::BindOnce(&Device::SendFolderUpdate, device.get()->Get(),
+                                     available_players, addressed_players, uids));
   }
 }
 
@@ -522,8 +522,8 @@ void AvrcpService::SendPlayerSettingsChanged(std::vector<PlayerAttribute> attrib
 
   // Ensure that the update is posted to the correct thread
   for (const auto& device : instance_->connection_handler_->GetListOfDevices()) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&Device::HandlePlayerSettingChanged,
-                                                device.get()->Get(), attributes, values));
+    do_in_main_thread(base::BindOnce(&Device::HandlePlayerSettingChanged, device.get()->Get(),
+                                     attributes, values));
   }
 }
 
@@ -551,38 +551,37 @@ void AvrcpService::ServiceInterfaceImpl::Init(MediaInterface* media_interface,
   log::assert_that(instance_ == nullptr, "assert failed: instance_ == nullptr");
   instance_ = new AvrcpService();
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&AvrcpService::Init, base::Unretained(instance_),
+  do_in_main_thread(base::BindOnce(&AvrcpService::Init, base::Unretained(instance_),
                                    media_interface, volume_interface, player_settings_interface));
 }
 
 void AvrcpService::ServiceInterfaceImpl::RegisterBipServer(int psm) {
   std::lock_guard<std::mutex> lock(service_interface_lock_);
   log::assert_that(instance_ != nullptr, "assert failed: instance_ != nullptr");
-  do_in_main_thread(FROM_HERE, base::BindOnce(&AvrcpService::RegisterBipServer,
-                                              base::Unretained(instance_), psm));
+  do_in_main_thread(
+          base::BindOnce(&AvrcpService::RegisterBipServer, base::Unretained(instance_), psm));
 }
 
 void AvrcpService::ServiceInterfaceImpl::UnregisterBipServer() {
   std::lock_guard<std::mutex> lock(service_interface_lock_);
   log::assert_that(instance_ != nullptr, "assert failed: instance_ != nullptr");
-  do_in_main_thread(FROM_HERE, base::BindOnce(&AvrcpService::UnregisterBipServer,
-                                              base::Unretained(instance_)));
+  do_in_main_thread(
+          base::BindOnce(&AvrcpService::UnregisterBipServer, base::Unretained(instance_)));
 }
 
 bool AvrcpService::ServiceInterfaceImpl::ConnectDevice(const RawAddress& bdaddr) {
   std::lock_guard<std::mutex> lock(service_interface_lock_);
   log::assert_that(instance_ != nullptr, "assert failed: instance_ != nullptr");
-  do_in_main_thread(FROM_HERE, base::BindOnce(&AvrcpService::ConnectDevice,
-                                              base::Unretained(instance_), bdaddr));
+  do_in_main_thread(
+          base::BindOnce(&AvrcpService::ConnectDevice, base::Unretained(instance_), bdaddr));
   return true;
 }
 
 bool AvrcpService::ServiceInterfaceImpl::DisconnectDevice(const RawAddress& bdaddr) {
   std::lock_guard<std::mutex> lock(service_interface_lock_);
   log::assert_that(instance_ != nullptr, "assert failed: instance_ != nullptr");
-  do_in_main_thread(FROM_HERE, base::BindOnce(&AvrcpService::DisconnectDevice,
-                                              base::Unretained(instance_), bdaddr));
+  do_in_main_thread(
+          base::BindOnce(&AvrcpService::DisconnectDevice, base::Unretained(instance_), bdaddr));
   return true;
 }
 
@@ -611,8 +610,8 @@ void AvrcpService::ServiceInterfaceImpl::SetBipClientStatus(const RawAddress& bd
                                                             bool connected) {
   std::lock_guard<std::mutex> lock(service_interface_lock_);
   log::assert_that(instance_ != nullptr, "assert failed: instance_ != nullptr");
-  do_in_main_thread(FROM_HERE, base::BindOnce(&AvrcpService::SetBipClientStatus,
-                                              base::Unretained(instance_), bdaddr, connected));
+  do_in_main_thread(base::BindOnce(&AvrcpService::SetBipClientStatus, base::Unretained(instance_),
+                                   bdaddr, connected));
 }
 
 bool AvrcpService::ServiceInterfaceImpl::Cleanup() {
@@ -622,7 +621,7 @@ bool AvrcpService::ServiceInterfaceImpl::Cleanup() {
     return false;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&AvrcpService::Cleanup, base::Owned(instance_)));
+  do_in_main_thread(base::BindOnce(&AvrcpService::Cleanup, base::Owned(instance_)));
 
   // Setting instance to nullptr here is fine since it will be deleted on the
   // other thread.
diff --git a/system/btif/src/bluetooth.cc b/system/btif/src/bluetooth.cc
index 6bf35f5b4d..9711a6a157 100644
--- a/system/btif/src/bluetooth.cc
+++ b/system/btif/src/bluetooth.cc
@@ -514,7 +514,7 @@ static int get_adapter_properties(void) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_get_adapter_properties));
+  do_in_main_thread(base::BindOnce(btif_get_adapter_properties));
   return BT_STATUS_SUCCESS;
 }
 
@@ -524,12 +524,12 @@ static int get_adapter_property(bt_property_type_t type) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_get_adapter_property, type));
+  do_in_main_thread(base::BindOnce(btif_get_adapter_property, type));
   return BT_STATUS_SUCCESS;
 }
 
 static void set_scan_mode(bt_scan_mode_t mode) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_set_scan_mode, mode));
+  do_in_main_thread(base::BindOnce(btif_set_scan_mode, mode));
 }
 
 static int set_adapter_property(const bt_property_t* property) {
@@ -546,12 +546,12 @@ static int set_adapter_property(const bt_property_t* property) {
       return BT_STATUS_UNHANDLED;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](bt_property_t* property) {
-                                         btif_set_adapter_property(property);
-                                         osi_free(property);
-                                       },
-                                       property_deep_copy(property)));
+  do_in_main_thread(base::BindOnce(
+          [](bt_property_t* property) {
+            btif_set_adapter_property(property);
+            osi_free(property);
+          },
+          property_deep_copy(property)));
   return BT_STATUS_SUCCESS;
 }
 
@@ -560,7 +560,7 @@ int get_remote_device_properties(RawAddress* remote_addr) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_get_remote_device_properties, *remote_addr));
+  do_in_main_thread(base::BindOnce(btif_get_remote_device_properties, *remote_addr));
   return BT_STATUS_SUCCESS;
 }
 
@@ -569,7 +569,7 @@ int get_remote_device_property(RawAddress* remote_addr, bt_property_type_t type)
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_get_remote_device_property, *remote_addr, type));
+  do_in_main_thread(base::BindOnce(btif_get_remote_device_property, *remote_addr, type));
   return BT_STATUS_SUCCESS;
 }
 
@@ -578,12 +578,12 @@ int set_remote_device_property(RawAddress* remote_addr, const bt_property_t* pro
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](RawAddress remote_addr, bt_property_t* property) {
-                                         btif_set_remote_device_property(&remote_addr, property);
-                                         osi_free(property);
-                                       },
-                                       *remote_addr, property_deep_copy(property)));
+  do_in_main_thread(base::BindOnce(
+          [](RawAddress remote_addr, bt_property_t* property) {
+            btif_set_remote_device_property(&remote_addr, property);
+            osi_free(property);
+          },
+          *remote_addr, property_deep_copy(property)));
   return BT_STATUS_SUCCESS;
 }
 
@@ -592,8 +592,7 @@ int get_remote_services(RawAddress* remote_addr, int transport) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btif_dm_get_remote_services, *remote_addr, transport));
+  do_in_main_thread(base::BindOnce(btif_dm_get_remote_services, *remote_addr, transport));
   return BT_STATUS_SUCCESS;
 }
 
@@ -602,7 +601,7 @@ static int start_discovery(void) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_start_discovery));
+  do_in_main_thread(base::BindOnce(btif_dm_start_discovery));
   return BT_STATUS_SUCCESS;
 }
 
@@ -611,7 +610,7 @@ static int cancel_discovery(void) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_cancel_discovery));
+  do_in_main_thread(base::BindOnce(btif_dm_cancel_discovery));
   return BT_STATUS_SUCCESS;
 }
 
@@ -623,7 +622,7 @@ static int create_bond(const RawAddress* bd_addr, int transport) {
     return BT_STATUS_BUSY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_create_bond, *bd_addr, transport));
+  do_in_main_thread(base::BindOnce(btif_dm_create_bond, *bd_addr, transport));
   return BT_STATUS_SUCCESS;
 }
 
@@ -635,7 +634,7 @@ static int create_bond_le(const RawAddress* bd_addr, uint8_t addr_type) {
     return BT_STATUS_BUSY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_create_bond_le, *bd_addr, addr_type));
+  do_in_main_thread(base::BindOnce(btif_dm_create_bond_le, *bd_addr, addr_type));
   return BT_STATUS_SUCCESS;
 }
 
@@ -648,8 +647,8 @@ static int create_bond_out_of_band(const RawAddress* bd_addr, int transport,
     return BT_STATUS_BUSY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_create_bond_out_of_band, *bd_addr, transport,
-                                              *p192_data, *p256_data));
+  do_in_main_thread(base::BindOnce(btif_dm_create_bond_out_of_band, *bd_addr, transport, *p192_data,
+                                   *p256_data));
   return BT_STATUS_SUCCESS;
 }
 
@@ -659,7 +658,7 @@ static int generate_local_oob_data(tBT_TRANSPORT transport) {
     return BT_STATUS_NOT_READY;
   }
 
-  return do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_generate_local_oob_data, transport));
+  return do_in_main_thread(base::BindOnce(btif_dm_generate_local_oob_data, transport));
 }
 
 static int cancel_bond(const RawAddress* bd_addr) {
@@ -667,7 +666,7 @@ static int cancel_bond(const RawAddress* bd_addr) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_cancel_bond, *bd_addr));
+  do_in_main_thread(base::BindOnce(btif_dm_cancel_bond, *bd_addr));
   return BT_STATUS_SUCCESS;
 }
 
@@ -681,7 +680,7 @@ static int remove_bond(const RawAddress* bd_addr) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_remove_bond, *bd_addr));
+  do_in_main_thread(base::BindOnce(btif_dm_remove_bond, *bd_addr));
   return BT_STATUS_SUCCESS;
 }
 
@@ -717,8 +716,7 @@ static int pin_reply(const RawAddress* bd_addr, uint8_t accept, uint8_t pin_len,
 
   memcpy(&tmp_pin_code, pin_code, pin_len);
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btif_dm_pin_reply, *bd_addr, accept, pin_len, tmp_pin_code));
+  do_in_main_thread(base::BindOnce(btif_dm_pin_reply, *bd_addr, accept, pin_len, tmp_pin_code));
   return BT_STATUS_SUCCESS;
 }
 
@@ -731,7 +729,7 @@ static int ssp_reply(const RawAddress* bd_addr, bt_ssp_variant_t variant, uint8_
     return BT_STATUS_PARM_INVALID;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_ssp_reply, *bd_addr, variant, accept));
+  do_in_main_thread(base::BindOnce(btif_dm_ssp_reply, *bd_addr, variant, accept));
   return BT_STATUS_SUCCESS;
 }
 
@@ -740,7 +738,7 @@ static int read_energy_info() {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_read_energy_info));
+  do_in_main_thread(base::BindOnce(btif_dm_read_energy_info));
   return BT_STATUS_SUCCESS;
 }
 
@@ -750,7 +748,7 @@ static int clear_event_filter() {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_clear_event_filter));
+  do_in_main_thread(base::BindOnce(btif_dm_clear_event_filter));
   return BT_STATUS_SUCCESS;
 }
 
@@ -760,7 +758,7 @@ static int clear_event_mask() {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_clear_event_mask));
+  do_in_main_thread(base::BindOnce(btif_dm_clear_event_mask));
   return BT_STATUS_SUCCESS;
 }
 
@@ -770,7 +768,7 @@ static int clear_filter_accept_list() {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_clear_filter_accept_list));
+  do_in_main_thread(base::BindOnce(btif_dm_clear_filter_accept_list));
   return BT_STATUS_SUCCESS;
 }
 
@@ -780,7 +778,7 @@ static int disconnect_all_acls() {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_disconnect_all_acls));
+  do_in_main_thread(base::BindOnce(btif_dm_disconnect_all_acls));
   return BT_STATUS_SUCCESS;
 }
 
@@ -796,8 +794,7 @@ static int le_rand() {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btif_dm_le_rand, get_main_thread()->BindOnce(&le_rand_btif_cb)));
+  do_in_main_thread(base::BindOnce(btif_dm_le_rand, get_main_thread()->BindOnce(&le_rand_btif_cb)));
   return BT_STATUS_SUCCESS;
 }
 
@@ -805,7 +802,7 @@ static int set_event_filter_inquiry_result_all_devices() {
   if (!interface_ready()) {
     return BT_STATUS_NOT_READY;
   }
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_set_event_filter_inquiry_result_all_devices));
+  do_in_main_thread(base::BindOnce(btif_dm_set_event_filter_inquiry_result_all_devices));
   return BT_STATUS_SUCCESS;
 }
 
@@ -813,8 +810,7 @@ static int set_default_event_mask_except(uint64_t mask, uint64_t le_mask) {
   if (!interface_ready()) {
     return BT_STATUS_NOT_READY;
   }
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btif_dm_set_default_event_mask_except, mask, le_mask));
+  do_in_main_thread(base::BindOnce(btif_dm_set_default_event_mask_except, mask, le_mask));
   return BT_STATUS_SUCCESS;
 }
 
@@ -828,8 +824,7 @@ static int restore_filter_accept_list() {
   // connections that have `is_direct=False`. Currently, we only restore LE hid
   // devices.
   auto le_hid_addrs = btif_storage_get_le_hid_devices();
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btif_dm_restore_filter_accept_list, std::move(le_hid_addrs)));
+  do_in_main_thread(base::BindOnce(btif_dm_restore_filter_accept_list, std::move(le_hid_addrs)));
   return BT_STATUS_SUCCESS;
 }
 
@@ -839,8 +834,7 @@ static int allow_wake_by_hid() {
   }
   auto le_hid_addrs = btif_storage_get_le_hid_devices();
   auto classic_hid_addrs = btif_storage_get_wake_capable_classic_hid_devices();
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btif_dm_allow_wake_by_hid, std::move(classic_hid_addrs),
+  do_in_main_thread(base::BindOnce(btif_dm_allow_wake_by_hid, std::move(classic_hid_addrs),
                                    std::move(le_hid_addrs)));
   return BT_STATUS_SUCCESS;
 }
@@ -849,8 +843,7 @@ static int set_event_filter_connection_setup_all_devices() {
   if (!interface_ready()) {
     return BT_STATUS_NOT_READY;
   }
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btif_dm_set_event_filter_connection_setup_all_devices));
+  do_in_main_thread(base::BindOnce(btif_dm_set_event_filter_connection_setup_all_devices));
   return BT_STATUS_SUCCESS;
 }
 
@@ -1003,7 +996,7 @@ int dut_mode_configure(uint8_t enable) {
     return BT_STATUS_NOT_READY;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dut_mode_configure, enable));
+  do_in_main_thread(base::BindOnce(btif_dut_mode_configure, enable));
   return BT_STATUS_SUCCESS;
 }
 
@@ -1018,12 +1011,12 @@ int dut_mode_send(uint16_t opcode, uint8_t* buf, uint8_t len) {
   uint8_t* copy = (uint8_t*)osi_calloc(len);
   memcpy(copy, buf, len);
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(
-                                       [](uint16_t opcode, uint8_t* buf, uint8_t len) {
-                                         btif_dut_mode_send(opcode, buf, len);
-                                         osi_free(buf);
-                                       },
-                                       opcode, copy, len));
+  do_in_main_thread(base::BindOnce(
+          [](uint16_t opcode, uint8_t* buf, uint8_t len) {
+            btif_dut_mode_send(opcode, buf, len);
+            osi_free(buf);
+          },
+          opcode, copy, len));
   return BT_STATUS_SUCCESS;
 }
 
@@ -1037,17 +1030,16 @@ int le_test_mode(uint16_t opcode, uint8_t* buf, uint8_t len) {
       if (len != 3) {
         return BT_STATUS_PARM_INVALID;
       }
-      do_in_main_thread(FROM_HERE,
-                        base::BindOnce(btif_ble_transmitter_test, buf[0], buf[1], buf[2]));
+      do_in_main_thread(base::BindOnce(btif_ble_transmitter_test, buf[0], buf[1], buf[2]));
       break;
     case HCI_BLE_RECEIVER_TEST:
       if (len != 1) {
         return BT_STATUS_PARM_INVALID;
       }
-      do_in_main_thread(FROM_HERE, base::BindOnce(btif_ble_receiver_test, buf[0]));
+      do_in_main_thread(base::BindOnce(btif_ble_receiver_test, buf[0]));
       break;
     case HCI_BLE_TEST_END:
-      do_in_main_thread(FROM_HERE, base::BindOnce(btif_ble_test_end));
+      do_in_main_thread(base::BindOnce(btif_ble_test_end));
       break;
     default:
       return BT_STATUS_UNSUPPORTED;
@@ -1115,7 +1107,6 @@ static bool allow_low_latency_audio(bool allowed, const RawAddress& /* address *
   log::info("{}", allowed);
   if (com::android::bluetooth::flags::a2dp_async_allow_low_latency()) {
     do_in_main_thread(
-            FROM_HERE,
             base::BindOnce(bluetooth::audio::a2dp::set_audio_low_latency_mode_allowed, allowed));
   } else {
     bluetooth::audio::a2dp::set_audio_low_latency_mode_allowed(allowed);
@@ -1130,8 +1121,8 @@ static void metadata_changed(const RawAddress& remote_bd_addr, int key,
     return;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btif_dm_metadata_changed, remote_bd_addr, key,
-                                              std::move(value)));
+  do_in_main_thread(
+          base::BindOnce(btif_dm_metadata_changed, remote_bd_addr, key, std::move(value)));
 }
 
 static bool interop_match_addr(const char* feature_name, const RawAddress* addr) {
diff --git a/system/btif/src/btif_av.cc b/system/btif/src/btif_av.cc
index 063c3ce5e6..1723c37c7b 100644
--- a/system/btif/src/btif_av.cc
+++ b/system/btif/src/btif_av.cc
@@ -1225,10 +1225,10 @@ void BtifAvSource::Cleanup() {
   btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SOURCE);
 
   std::promise<void> peer_ready_promise;
-  do_in_main_thread(FROM_HERE, base::BindOnce(base::IgnoreResult(&BtifAvSource::SetActivePeer),
-                                              base::Unretained(&btif_av_source), RawAddress::kEmpty,
-                                              std::move(peer_ready_promise)));
-  do_in_main_thread(FROM_HERE, base::BindOnce(&btif_a2dp_source_cleanup));
+  do_in_main_thread(base::BindOnce(base::IgnoreResult(&BtifAvSource::SetActivePeer),
+                                   base::Unretained(&btif_av_source), RawAddress::kEmpty,
+                                   std::move(peer_ready_promise)));
+  do_in_main_thread(base::BindOnce(&btif_a2dp_source_cleanup));
 
   btif_disable_service(BTA_A2DP_SOURCE_SERVICE_ID);
   CleanupAllPeers();
@@ -1519,10 +1519,10 @@ void BtifAvSink::Cleanup() {
   btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SINK);
 
   std::promise<void> peer_ready_promise;
-  do_in_main_thread(FROM_HERE, base::BindOnce(base::IgnoreResult(&BtifAvSink::SetActivePeer),
-                                              base::Unretained(&btif_av_sink), RawAddress::kEmpty,
-                                              std::move(peer_ready_promise)));
-  do_in_main_thread(FROM_HERE, base::BindOnce(&btif_a2dp_sink_cleanup));
+  do_in_main_thread(base::BindOnce(base::IgnoreResult(&BtifAvSink::SetActivePeer),
+                                   base::Unretained(&btif_av_sink), RawAddress::kEmpty,
+                                   std::move(peer_ready_promise)));
+  do_in_main_thread(base::BindOnce(&btif_a2dp_sink_cleanup));
 
   btif_disable_service(BTA_A2DP_SINK_SERVICE_ID);
   CleanupAllPeers();
@@ -1783,11 +1783,11 @@ void BtifAvStateMachine::StateIdle::OnEnter() {
 
   // Delete peers that are re-entering the Idle state
   if (peer_.IsSink()) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&BtifAvSource::DeleteIdlePeers,
-                                                base::Unretained(&btif_av_source)));
+    do_in_main_thread(
+            base::BindOnce(&BtifAvSource::DeleteIdlePeers, base::Unretained(&btif_av_source)));
   } else if (peer_.IsSource()) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(&BtifAvSink::DeleteIdlePeers,
-                                                base::Unretained(&btif_av_sink)));
+    do_in_main_thread(
+            base::BindOnce(&BtifAvSink::DeleteIdlePeers, base::Unretained(&btif_av_sink)));
   }
 }
 
@@ -3044,7 +3044,7 @@ static void btif_av_query_mandatory_codec_priority(const RawAddress& peer_addres
         }
         peer->SetMandatoryCodecPreferred(preferred);
       };
-      do_in_main_thread(FROM_HERE, base::BindOnce(apply_priority, peer_address, preferred));
+      do_in_main_thread(base::BindOnce(apply_priority, peer_address, preferred));
     }
   };
   if (btif_av_source.Enabled()) {
@@ -3369,21 +3369,21 @@ static void bta_av_source_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
   BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
   log::verbose("event={}", btif_av_event.ToString());
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&btif_av_handle_bta_av_event,
-                                              AVDT_TSEP_SNK /* peer_sep */, btif_av_event));
+  do_in_main_thread(base::BindOnce(&btif_av_handle_bta_av_event, AVDT_TSEP_SNK /* peer_sep */,
+                                   btif_av_event));
 }
 
 static void bta_av_sink_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
   BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
-  do_in_main_thread(FROM_HERE, base::BindOnce(&btif_av_handle_bta_av_event,
-                                              AVDT_TSEP_SRC /* peer_sep */, btif_av_event));
+  do_in_main_thread(base::BindOnce(&btif_av_handle_bta_av_event, AVDT_TSEP_SRC /* peer_sep */,
+                                   btif_av_event));
 }
 
 static void bta_av_event_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
   if (btif_av_both_enable()) {
     BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
-    do_in_main_thread(FROM_HERE, base::BindOnce(&btif_av_handle_bta_av_event,
-                                                AVDT_TSEP_INVALID /* peer_sep */, btif_av_event));
+    do_in_main_thread(base::BindOnce(&btif_av_handle_bta_av_event, AVDT_TSEP_INVALID /* peer_sep */,
+                                     btif_av_event));
     return;
   }
 
@@ -3432,8 +3432,7 @@ static void bta_av_sink_media_callback(const RawAddress& peer_address, tBTA_AV_E
       }
       config_req.peer_address = p_data->avk_config.bd_addr;
       BtifAvEvent btif_av_event(BTIF_AV_SINK_CONFIG_REQ_EVT, &config_req, sizeof(config_req));
-      do_in_main_thread(FROM_HERE,
-                        base::BindOnce(&btif_av_handle_event,
+      do_in_main_thread(base::BindOnce(&btif_av_handle_event,
                                        AVDT_TSEP_SRC,  // peer_sep
                                        config_req.peer_address, kBtaHandleUnknown, btif_av_event));
       break;
@@ -3498,8 +3497,7 @@ static bt_status_t connect_int(RawAddress* peer_address, uint16_t uuid) {
     }
     peer->StateMachine().ProcessEvent(BTIF_AV_CONNECT_REQ_EVT, nullptr);
   };
-  bt_status_t status =
-          do_in_main_thread(FROM_HERE, base::BindOnce(connection_task, peer_address, uuid));
+  bt_status_t status = do_in_main_thread(base::BindOnce(connection_task, peer_address, uuid));
   if (status != BT_STATUS_SUCCESS) {
     log::error("can't post connection task to main_thread");
   }
@@ -3580,8 +3578,7 @@ bt_status_t btif_av_source_disconnect(const RawAddress& peer_address) {
   }
 
   BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address, sizeof(peer_address));
-  return do_in_main_thread(FROM_HERE,
-                           base::BindOnce(&btif_av_handle_event,
+  return do_in_main_thread(base::BindOnce(&btif_av_handle_event,
                                           AVDT_TSEP_SNK,  // peer_sep
                                           peer_address, kBtaHandleUnknown, btif_av_event));
 }
@@ -3595,8 +3592,7 @@ bt_status_t btif_av_sink_disconnect(const RawAddress& peer_address) {
   }
 
   BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address, sizeof(peer_address));
-  return do_in_main_thread(FROM_HERE,
-                           base::BindOnce(&btif_av_handle_event,
+  return do_in_main_thread(base::BindOnce(&btif_av_handle_event,
                                           AVDT_TSEP_SRC,  // peer_sep
                                           peer_address, kBtaHandleUnknown, btif_av_event));
 }
@@ -3612,9 +3608,9 @@ bt_status_t btif_av_sink_set_active_device(const RawAddress& peer_address) {
   std::promise<void> peer_ready_promise;
   std::future<void> peer_ready_future = peer_ready_promise.get_future();
   bt_status_t status =
-          do_in_main_thread(FROM_HERE, base::BindOnce(&set_active_peer_int,
-                                                      AVDT_TSEP_SRC,  // peer_sep
-                                                      peer_address, std::move(peer_ready_promise)));
+          do_in_main_thread(base::BindOnce(&set_active_peer_int,
+                                           AVDT_TSEP_SRC,  // peer_sep
+                                           peer_address, std::move(peer_ready_promise)));
   if (status == BT_STATUS_SUCCESS) {
     peer_ready_future.wait();
   } else {
@@ -3631,8 +3627,7 @@ bt_status_t btif_av_source_set_silence_device(const RawAddress& peer_address, bo
     return BT_STATUS_NOT_READY;
   }
 
-  return do_in_main_thread(FROM_HERE,
-                           base::BindOnce(&set_source_silence_peer_int, peer_address, silence));
+  return do_in_main_thread(base::BindOnce(&set_source_silence_peer_int, peer_address, silence));
 }
 
 bt_status_t btif_av_source_set_active_device(const RawAddress& peer_address) {
@@ -3646,9 +3641,9 @@ bt_status_t btif_av_source_set_active_device(const RawAddress& peer_address) {
   std::promise<void> peer_ready_promise;
   std::future<void> peer_ready_future = peer_ready_promise.get_future();
   bt_status_t status =
-          do_in_main_thread(FROM_HERE, base::BindOnce(&set_active_peer_int,
-                                                      AVDT_TSEP_SNK,  // peer_sep
-                                                      peer_address, std::move(peer_ready_promise)));
+          do_in_main_thread(base::BindOnce(&set_active_peer_int,
+                                           AVDT_TSEP_SNK,  // peer_sep
+                                           peer_address, std::move(peer_ready_promise)));
   if (status == BT_STATUS_SUCCESS) {
     peer_ready_future.wait();
   } else {
@@ -3674,7 +3669,6 @@ bt_status_t btif_av_source_set_codec_config_preference(
   std::promise<void> peer_ready_promise;
   std::future<void> peer_ready_future = peer_ready_promise.get_future();
   bt_status_t status = do_in_main_thread(
-          FROM_HERE,
           base::BindOnce(&BtifAvSource::UpdateCodecConfig, base::Unretained(&btif_av_source),
                          peer_address, codec_preferences, std::move(peer_ready_promise)));
   if (status == BT_STATUS_SUCCESS) {
@@ -3687,14 +3681,12 @@ bt_status_t btif_av_source_set_codec_config_preference(
 
 void btif_av_source_cleanup(void) {
   log::info("");
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&BtifAvSource::Cleanup, base::Unretained(&btif_av_source)));
+  do_in_main_thread(base::BindOnce(&BtifAvSource::Cleanup, base::Unretained(&btif_av_source)));
 }
 
 void btif_av_sink_cleanup(void) {
   log::info("");
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&BtifAvSink::Cleanup, base::Unretained(&btif_av_sink)));
+  do_in_main_thread(base::BindOnce(&BtifAvSink::Cleanup, base::Unretained(&btif_av_sink)));
 }
 
 RawAddress btif_av_source_active_peer(void) { return btif_av_source.ActivePeer(); }
@@ -3718,8 +3710,7 @@ void btif_av_stream_start_with_latency(bool use_latency_mode) {
   BtifAvEvent btif_av_event(BTIF_AV_START_STREAM_REQ_EVT, &start_stream_req,
                             sizeof(start_stream_req));
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&btif_av_handle_event,
+  do_in_main_thread(base::BindOnce(&btif_av_handle_event,
                                    AVDT_TSEP_SNK,  // peer_sep
                                    btif_av_source_active_peer(), kBtaHandleUnknown, btif_av_event));
 }
@@ -3803,9 +3794,9 @@ static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address,
   BtifAvEvent btif_av_event(event, nullptr, 0);
   log::verbose("peer={} event={}", peer_address, btif_av_event.ToString());
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&btif_av_handle_event,
-                                              AVDT_TSEP_SNK,  // peer_sep
-                                              peer_address, kBtaHandleUnknown, btif_av_event));
+  do_in_main_thread(base::BindOnce(&btif_av_handle_event,
+                                   AVDT_TSEP_SNK,  // peer_sep
+                                   peer_address, kBtaHandleUnknown, btif_av_event));
 }
 
 static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address,
@@ -3813,9 +3804,9 @@ static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address,
   BtifAvEvent btif_av_event(event, nullptr, 0);
   log::verbose("peer={} event={}", peer_address, btif_av_event.ToString());
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&btif_av_handle_event,
-                                              AVDT_TSEP_SRC,  // peer_sep
-                                              peer_address, kBtaHandleUnknown, btif_av_event));
+  do_in_main_thread(base::BindOnce(&btif_av_handle_event,
+                                   AVDT_TSEP_SRC,  // peer_sep
+                                   peer_address, kBtaHandleUnknown, btif_av_event));
 }
 
 bt_status_t btif_av_source_execute_service(bool enable) {
@@ -3920,7 +3911,7 @@ void btif_av_clear_remote_suspend_flag(const A2dpType local_a2dp_type) {
     peer->ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
   };
   // switch to main thread to prevent a race condition of accessing peers
-  do_in_main_thread(FROM_HERE, base::BindOnce(clear_remote_suspend_flag, local_a2dp_type));
+  do_in_main_thread(base::BindOnce(clear_remote_suspend_flag, local_a2dp_type));
 }
 
 bool btif_av_is_peer_edr(const RawAddress& peer_address, const A2dpType local_a2dp_type) {
@@ -4105,8 +4096,7 @@ void btif_av_set_low_latency(bool is_low_latency) {
   set_latency_req.is_low_latency = is_low_latency;
   BtifAvEvent btif_av_event(BTIF_AV_SET_LATENCY_REQ_EVT, &set_latency_req, sizeof(set_latency_req));
 
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&btif_av_handle_event,
+  do_in_main_thread(base::BindOnce(&btif_av_handle_event,
                                    AVDT_TSEP_SNK,  // peer_sep
                                    btif_av_source_active_peer(), kBtaHandleUnknown, btif_av_event));
 }
diff --git a/system/btif/src/btif_csis_client.cc b/system/btif/src/btif_csis_client.cc
index 6d0ced8553..a7aef9f57b 100644
--- a/system/btif/src/btif_csis_client.cc
+++ b/system/btif/src/btif_csis_client.cc
@@ -50,8 +50,7 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
   void Init(CsisClientCallbacks* callbacks) override {
     this->callbacks_ = callbacks;
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&CsisClient::Initialize, this,
+    do_in_main_thread(Bind(&CsisClient::Initialize, this,
                            jni_thread_wrapper(Bind(&btif_storage_load_bonded_csis_devices))));
     /* It might be not yet initialized, but setting this flag here is safe,
      * because other calls will check this and the native instance
@@ -67,7 +66,7 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&CsisClient::Connect, Unretained(CsisClient::Get()), addr));
+    do_in_main_thread(Bind(&CsisClient::Connect, Unretained(CsisClient::Get()), addr));
   }
 
   void Disconnect(const RawAddress& addr) override {
@@ -78,8 +77,7 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&CsisClient::Disconnect, Unretained(CsisClient::Get()), addr));
+    do_in_main_thread(Bind(&CsisClient::Disconnect, Unretained(CsisClient::Get()), addr));
   }
 
   void RemoveDevice(const RawAddress& addr) override {
@@ -93,8 +91,7 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&CsisClient::RemoveDevice, Unretained(CsisClient::Get()), addr));
+    do_in_main_thread(Bind(&CsisClient::RemoveDevice, Unretained(CsisClient::Get()), addr));
     /* Clear storage */
     do_in_jni_thread(Bind(&btif_storage_remove_csis_device, addr));
   }
@@ -107,8 +104,8 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&CsisClient::LockGroup, Unretained(CsisClient::Get()),
-                                      group_id, lock, base::DoNothing()));
+    do_in_main_thread(Bind(&CsisClient::LockGroup, Unretained(CsisClient::Get()), group_id, lock,
+                           base::DoNothing()));
   }
 
   void Cleanup(void) override {
@@ -120,7 +117,7 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
     }
 
     initialized = false;
-    do_in_main_thread(FROM_HERE, Bind(&CsisClient::CleanUp));
+    do_in_main_thread(Bind(&CsisClient::CleanUp));
   }
 
   void OnConnectionState(const RawAddress& addr, ConnectionState state) override {
diff --git a/system/btif/src/btif_dm.cc b/system/btif/src/btif_dm.cc
index 5a84f1ef27..a85c2e8c84 100644
--- a/system/btif/src/btif_dm.cc
+++ b/system/btif/src/btif_dm.cc
@@ -890,18 +890,17 @@ uint16_t btif_dm_get_connection_state_sync(const RawAddress& bd_addr) {
   std::promise<uint16_t> promise;
   std::future future = promise.get_future();
 
-  auto status = do_in_main_thread(
-          FROM_HERE, base::BindOnce(
-                             [](const RawAddress bd_addr, std::promise<uint16_t> promise) {
-                               // Experiment to try with maybe resolved address
-                               uint16_t state = btif_dm_get_resolved_connection_state({
-                                       .type = BLE_ADDR_RANDOM,
-                                       .bda = bd_addr,
-                               });
-                               state |= btif_dm_get_connection_state(bd_addr);
-                               promise.set_value(state);
-                             },
-                             bd_addr, std::move(promise)));
+  auto status = do_in_main_thread(base::BindOnce(
+          [](const RawAddress bd_addr, std::promise<uint16_t> promise) {
+            // Experiment to try with maybe resolved address
+            uint16_t state = btif_dm_get_resolved_connection_state({
+                    .type = BLE_ADDR_RANDOM,
+                    .bda = bd_addr,
+            });
+            state |= btif_dm_get_connection_state(bd_addr);
+            promise.set_value(state);
+          },
+          bd_addr, std::move(promise)));
   log::assert_that(BT_STATUS_SUCCESS == status, "assert failed: BT_STATUS_SUCCESS == status");
   return future.get();
 }
@@ -1753,8 +1752,7 @@ void btif_on_gatt_results(RawAddress bd_addr, BD_NAME bd_name,
         /* LE Audio profile should relax parameters when it connects. If
          * profile is not enabled, relax parameters after timeout. */
         log::debug("Scheduling conn params unlock for {}", bd_addr);
-        do_in_main_thread_delayed(FROM_HERE,
-                                  base::BindOnce(
+        do_in_main_thread_delayed(base::BindOnce(
                                           [](RawAddress bd_addr) {
                                             L2CA_LockBleConnParamsForProfileConnection(bd_addr,
                                                                                        false);
diff --git a/system/btif/src/btif_gatt_client.cc b/system/btif/src/btif_gatt_client.cc
index 41dae81059..c5f0b84784 100644
--- a/system/btif/src/btif_gatt_client.cc
+++ b/system/btif/src/btif_gatt_client.cc
@@ -602,7 +602,7 @@ bt_status_t btif_gattc_conn_parameter_update(const RawAddress& bd_addr, int min_
 static bt_status_t btif_gattc_set_preferred_phy(const RawAddress& bd_addr, uint8_t tx_phy,
                                                 uint8_t rx_phy, uint16_t phy_options) {
   CHECK_BTGATT_INIT();
-  do_in_main_thread(FROM_HERE, Bind(&BTM_BleSetPhy, bd_addr, tx_phy, rx_phy, phy_options));
+  do_in_main_thread(Bind(&BTM_BleSetPhy, bd_addr, tx_phy, rx_phy, phy_options));
   return BT_STATUS_SUCCESS;
 }
 
@@ -610,7 +610,7 @@ static bt_status_t btif_gattc_read_phy(
         const RawAddress& bd_addr,
         base::Callback<void(uint8_t tx_phy, uint8_t rx_phy, uint8_t status)> cb) {
   CHECK_BTGATT_INIT();
-  do_in_main_thread(FROM_HERE, Bind(&BTM_BleReadPhy, bd_addr, jni_thread_wrapper(cb)));
+  do_in_main_thread(Bind(&BTM_BleReadPhy, bd_addr, jni_thread_wrapper(cb)));
   return BT_STATUS_SUCCESS;
 }
 
diff --git a/system/btif/src/btif_gatt_server.cc b/system/btif/src/btif_gatt_server.cc
index e5c4394b56..216d2c4587 100644
--- a/system/btif/src/btif_gatt_server.cc
+++ b/system/btif/src/btif_gatt_server.cc
@@ -430,7 +430,7 @@ static bt_status_t btif_gatts_send_response(int conn_id, int trans_id, int statu
 static bt_status_t btif_gatts_set_preferred_phy(const RawAddress& bd_addr, uint8_t tx_phy,
                                                 uint8_t rx_phy, uint16_t phy_options) {
   CHECK_BTGATT_INIT();
-  do_in_main_thread(FROM_HERE, Bind(&BTM_BleSetPhy, bd_addr, tx_phy, rx_phy, phy_options));
+  do_in_main_thread(Bind(&BTM_BleSetPhy, bd_addr, tx_phy, rx_phy, phy_options));
   return BT_STATUS_SUCCESS;
 }
 
@@ -438,7 +438,7 @@ static bt_status_t btif_gatts_read_phy(
         const RawAddress& bd_addr,
         base::Callback<void(uint8_t tx_phy, uint8_t rx_phy, uint8_t status)> cb) {
   CHECK_BTGATT_INIT();
-  do_in_main_thread(FROM_HERE, Bind(&BTM_BleReadPhy, bd_addr, jni_thread_wrapper(cb)));
+  do_in_main_thread(Bind(&BTM_BleReadPhy, bd_addr, jni_thread_wrapper(cb)));
   return BT_STATUS_SUCCESS;
 }
 
diff --git a/system/btif/src/btif_has_client.cc b/system/btif/src/btif_has_client.cc
index 9c2570fc72..41cb63131d 100644
--- a/system/btif/src/btif_has_client.cc
+++ b/system/btif/src/btif_has_client.cc
@@ -53,62 +53,59 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
     this->callbacks_ = callbacks;
 
     do_in_main_thread(
-            FROM_HERE,
             Bind(&HasClient::Initialize, this,
                  jni_thread_wrapper(Bind(&btif_storage_load_bonded_leaudio_has_devices))));
   }
 
   void Connect(const RawAddress& addr) override {
-    do_in_main_thread(FROM_HERE, Bind(&HasClient::Connect, Unretained(HasClient::Get()), addr));
+    do_in_main_thread(Bind(&HasClient::Connect, Unretained(HasClient::Get()), addr));
 
     do_in_jni_thread(Bind(&btif_storage_set_leaudio_has_acceptlist, addr, true));
   }
 
   void Disconnect(const RawAddress& addr) override {
-    do_in_main_thread(FROM_HERE, Bind(&HasClient::Disconnect, Unretained(HasClient::Get()), addr));
+    do_in_main_thread(Bind(&HasClient::Disconnect, Unretained(HasClient::Get()), addr));
 
     do_in_jni_thread(Bind(&btif_storage_set_leaudio_has_acceptlist, addr, false));
   }
 
   void SelectActivePreset(std::variant<RawAddress, int> addr_or_group_id,
                           uint8_t preset_index) override {
-    do_in_main_thread(FROM_HERE, Bind(&HasClient::SelectActivePreset, Unretained(HasClient::Get()),
-                                      std::move(addr_or_group_id), preset_index));
+    do_in_main_thread(Bind(&HasClient::SelectActivePreset, Unretained(HasClient::Get()),
+                           std::move(addr_or_group_id), preset_index));
   }
 
   void NextActivePreset(std::variant<RawAddress, int> addr_or_group_id) override {
-    do_in_main_thread(FROM_HERE, Bind(&HasClient::NextActivePreset, Unretained(HasClient::Get()),
-                                      std::move(addr_or_group_id)));
+    do_in_main_thread(Bind(&HasClient::NextActivePreset, Unretained(HasClient::Get()),
+                           std::move(addr_or_group_id)));
   }
 
   void PreviousActivePreset(std::variant<RawAddress, int> addr_or_group_id) override {
-    do_in_main_thread(FROM_HERE, Bind(&HasClient::PreviousActivePreset,
-                                      Unretained(HasClient::Get()), std::move(addr_or_group_id)));
+    do_in_main_thread(Bind(&HasClient::PreviousActivePreset, Unretained(HasClient::Get()),
+                           std::move(addr_or_group_id)));
   }
 
   void GetPresetInfo(const RawAddress& addr, uint8_t preset_index) override {
-    do_in_main_thread(FROM_HERE, Bind(&HasClient::GetPresetInfo, Unretained(HasClient::Get()), addr,
-                                      preset_index));
+    do_in_main_thread(
+            Bind(&HasClient::GetPresetInfo, Unretained(HasClient::Get()), addr, preset_index));
   }
 
   void SetPresetName(std::variant<RawAddress, int> addr_or_group_id, uint8_t preset_index,
                      std::string preset_name) override {
-    do_in_main_thread(FROM_HERE,
-                      Bind(&HasClient::SetPresetName, Unretained(HasClient::Get()),
+    do_in_main_thread(Bind(&HasClient::SetPresetName, Unretained(HasClient::Get()),
                            std::move(addr_or_group_id), preset_index, std::move(preset_name)));
   }
 
   void RemoveDevice(const RawAddress& addr) override {
     /* RemoveDevice can be called on devices that don't have BAS enabled */
     if (HasClient::IsHasClientRunning()) {
-      do_in_main_thread(FROM_HERE,
-                        Bind(&HasClient::Disconnect, Unretained(HasClient::Get()), addr));
+      do_in_main_thread(Bind(&HasClient::Disconnect, Unretained(HasClient::Get()), addr));
     }
 
     do_in_jni_thread(Bind(&btif_storage_remove_leaudio_has, addr));
   }
 
-  void Cleanup(void) override { do_in_main_thread(FROM_HERE, Bind(&HasClient::CleanUp)); }
+  void Cleanup(void) override { do_in_main_thread(Bind(&HasClient::CleanUp)); }
 
   void OnConnectionState(ConnectionState state, const RawAddress& addr) override {
     do_in_jni_thread(
diff --git a/system/btif/src/btif_hearing_aid.cc b/system/btif/src/btif_hearing_aid.cc
index 72b5aaed37..6ff13d02ac 100644
--- a/system/btif/src/btif_hearing_aid.cc
+++ b/system/btif/src/btif_hearing_aid.cc
@@ -51,8 +51,7 @@ class HearingAidInterfaceImpl : public bluetooth::hearing_aid::HearingAidInterfa
 
   void Init(HearingAidCallbacks* callbacks) override {
     this->callbacks = callbacks;
-    do_in_main_thread(FROM_HERE,
-                      Bind(&HearingAid::Initialize, this,
+    do_in_main_thread(Bind(&HearingAid::Initialize, this,
                            jni_thread_wrapper(Bind(&btif_storage_load_bonded_hearing_aids))));
   }
 
@@ -68,33 +67,33 @@ class HearingAidInterfaceImpl : public bluetooth::hearing_aid::HearingAidInterfa
   }
 
   void Connect(const RawAddress& address) override {
-    do_in_main_thread(FROM_HERE, Bind(&HearingAid::Connect, address));
+    do_in_main_thread(Bind(&HearingAid::Connect, address));
   }
 
   void Disconnect(const RawAddress& address) override {
-    do_in_main_thread(FROM_HERE, Bind(&HearingAid::Disconnect, address));
+    do_in_main_thread(Bind(&HearingAid::Disconnect, address));
     do_in_jni_thread(Bind(&btif_storage_set_hearing_aid_acceptlist, address, false));
   }
 
   void AddToAcceptlist(const RawAddress& address) override {
-    do_in_main_thread(FROM_HERE, Bind(&HearingAid::AddToAcceptlist, address));
+    do_in_main_thread(Bind(&HearingAid::AddToAcceptlist, address));
     do_in_jni_thread(Bind(&btif_storage_set_hearing_aid_acceptlist, address, true));
   }
 
   void SetVolume(int8_t volume) override {
-    do_in_main_thread(FROM_HERE, Bind(&HearingAid::SetVolume, volume));
+    do_in_main_thread(Bind(&HearingAid::SetVolume, volume));
   }
 
   void RemoveDevice(const RawAddress& address) override {
     // RemoveDevice can be called on devices that don't have HA enabled
     if (HearingAid::IsHearingAidRunning()) {
-      do_in_main_thread(FROM_HERE, Bind(&HearingAid::Disconnect, address));
+      do_in_main_thread(Bind(&HearingAid::Disconnect, address));
     }
 
     do_in_jni_thread(Bind(&btif_storage_remove_hearing_aid, address));
   }
 
-  void Cleanup(void) override { do_in_main_thread(FROM_HERE, Bind(&HearingAid::CleanUp)); }
+  void Cleanup(void) override { do_in_main_thread(Bind(&HearingAid::CleanUp)); }
 
 private:
   HearingAidCallbacks* callbacks;
diff --git a/system/btif/src/btif_le_audio.cc b/system/btif/src/btif_le_audio.cc
index f33e22dd24..e3dd8e5216 100644
--- a/system/btif/src/btif_le_audio.cc
+++ b/system/btif/src/btif_le_audio.cc
@@ -132,7 +132,6 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
     }
 
     do_in_main_thread(
-            FROM_HERE,
             Bind(&LeAudioClient::Initialize, this,
                  jni_thread_wrapper(Bind(&btif_storage_load_bonded_leaudio)),
                  base::Bind([]() -> bool { return LeAudioHalVerifier::SupportsLeAudio(); }),
@@ -154,7 +153,7 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
 
     initialized = false;
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::Cleanup));
+    do_in_main_thread(Bind(&LeAudioClient::Cleanup));
   }
 
   void RemoveDevice(const RawAddress& address) override {
@@ -167,8 +166,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::RemoveDevice,
-                                      Unretained(LeAudioClient::Get()), address));
+    do_in_main_thread(
+            Bind(&LeAudioClient::RemoveDevice, Unretained(LeAudioClient::Get()), address));
 
     do_in_jni_thread(Bind(&btif_storage_remove_leaudio, address));
   }
@@ -181,8 +180,7 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&LeAudioClient::Connect, Unretained(LeAudioClient::Get()), address));
+    do_in_main_thread(Bind(&LeAudioClient::Connect, Unretained(LeAudioClient::Get()), address));
   }
 
   void Disconnect(const RawAddress& address) override {
@@ -193,8 +191,7 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&LeAudioClient::Disconnect, Unretained(LeAudioClient::Get()), address));
+    do_in_main_thread(Bind(&LeAudioClient::Disconnect, Unretained(LeAudioClient::Get()), address));
   }
 
   void SetEnableState(const RawAddress& address, bool enabled) override {
@@ -205,8 +202,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::SetEnableState,
-                                      Unretained(LeAudioClient::Get()), address, enabled));
+    do_in_main_thread(Bind(&LeAudioClient::SetEnableState, Unretained(LeAudioClient::Get()),
+                           address, enabled));
   }
 
   void GroupAddNode(const int group_id, const RawAddress& address) override {
@@ -217,8 +214,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::GroupAddNode,
-                                      Unretained(LeAudioClient::Get()), group_id, address));
+    do_in_main_thread(Bind(&LeAudioClient::GroupAddNode, Unretained(LeAudioClient::Get()), group_id,
+                           address));
   }
 
   void GroupRemoveNode(const int group_id, const RawAddress& address) override {
@@ -229,8 +226,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::GroupRemoveNode,
-                                      Unretained(LeAudioClient::Get()), group_id, address));
+    do_in_main_thread(Bind(&LeAudioClient::GroupRemoveNode, Unretained(LeAudioClient::Get()),
+                           group_id, address));
   }
 
   void GroupSetActive(const int group_id) override {
@@ -241,8 +238,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::GroupSetActive,
-                                      Unretained(LeAudioClient::Get()), group_id));
+    do_in_main_thread(
+            Bind(&LeAudioClient::GroupSetActive, Unretained(LeAudioClient::Get()), group_id));
   }
 
   void SetCodecConfigPreference(int group_id, btle_audio_codec_config_t input_codec_config,
@@ -253,9 +250,9 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
               "being not read");
       return;
     }
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::SetCodecConfigPreference,
-                                      Unretained(LeAudioClient::Get()), group_id,
-                                      input_codec_config, output_codec_config));
+    do_in_main_thread(Bind(&LeAudioClient::SetCodecConfigPreference,
+                           Unretained(LeAudioClient::Get()), group_id, input_codec_config,
+                           output_codec_config));
   }
 
   void SetCcidInformation(int ccid, int context_type) {
@@ -266,8 +263,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::SetCcidInformation,
-                                      Unretained(LeAudioClient::Get()), ccid, context_type));
+    do_in_main_thread(Bind(&LeAudioClient::SetCcidInformation, Unretained(LeAudioClient::Get()),
+                           ccid, context_type));
   }
 
   void SetInCall(bool in_call) {
@@ -278,8 +275,7 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&LeAudioClient::SetInCall, Unretained(LeAudioClient::Get()), in_call));
+    do_in_main_thread(Bind(&LeAudioClient::SetInCall, Unretained(LeAudioClient::Get()), in_call));
   }
 
   void SetUnicastMonitorMode(uint8_t direction, bool enable) {
@@ -291,8 +287,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::SetUnicastMonitorMode,
-                                      Unretained(LeAudioClient::Get()), direction, enable));
+    do_in_main_thread(Bind(&LeAudioClient::SetUnicastMonitorMode, Unretained(LeAudioClient::Get()),
+                           direction, enable));
   }
 
   void SendAudioProfilePreferences(int group_id, bool is_output_preference_le_audio,
@@ -304,10 +300,9 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
       return;
     }
 
-    do_in_main_thread(
-            FROM_HERE,
-            Bind(&LeAudioClient::SendAudioProfilePreferences, Unretained(LeAudioClient::Get()),
-                 group_id, is_output_preference_le_audio, is_duplex_preference_le_audio));
+    do_in_main_thread(Bind(&LeAudioClient::SendAudioProfilePreferences,
+                           Unretained(LeAudioClient::Get()), group_id,
+                           is_output_preference_le_audio, is_duplex_preference_le_audio));
   }
 
   void SetGroupAllowedContextMask(int group_id, int sink_context_types, int source_context_types) {
@@ -321,9 +316,9 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface, public LeAudio
     log::info("group_id: {}, sink context types: {}, source context types: {}", group_id,
               sink_context_types, source_context_types);
 
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioClient::SetGroupAllowedContextMask,
-                                      Unretained(LeAudioClient::Get()), group_id,
-                                      sink_context_types, source_context_types));
+    do_in_main_thread(Bind(&LeAudioClient::SetGroupAllowedContextMask,
+                           Unretained(LeAudioClient::Get()), group_id, sink_context_types,
+                           source_context_types));
   }
 
 private:
diff --git a/system/btif/src/btif_le_audio_broadcaster.cc b/system/btif/src/btif_le_audio_broadcaster.cc
index d5f3a53ce3..263863a259 100644
--- a/system/btif/src/btif_le_audio_broadcaster.cc
+++ b/system/btif/src/btif_le_audio_broadcaster.cc
@@ -41,54 +41,52 @@ class LeAudioBroadcasterInterfaceImpl : public LeAudioBroadcasterInterface,
 
   void Initialize(LeAudioBroadcasterCallbacks* callbacks) override {
     this->callbacks_ = callbacks;
-    do_in_main_thread(FROM_HERE,
-                      Bind(&LeAudioBroadcaster::Initialize, this, base::Bind([]() -> bool {
-                        return LeAudioHalVerifier::SupportsLeAudioBroadcast();
-                      })));
+    do_in_main_thread(Bind(&LeAudioBroadcaster::Initialize, this, base::Bind([]() -> bool {
+      return LeAudioHalVerifier::SupportsLeAudioBroadcast();
+    })));
   }
 
   void CreateBroadcast(bool is_public, std::string broadcast_name,
                        std::optional<bluetooth::le_audio::BroadcastCode> broadcast_code,
                        std::vector<uint8_t> public_metadata, std::vector<uint8_t> subgroup_quality,
                        std::vector<std::vector<uint8_t>> subgroup_metadata) override {
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::CreateAudioBroadcast,
-                                      Unretained(LeAudioBroadcaster::Get()), is_public,
-                                      broadcast_name, broadcast_code, std::move(public_metadata),
-                                      std::move(subgroup_quality), std::move(subgroup_metadata)));
+    do_in_main_thread(Bind(&LeAudioBroadcaster::CreateAudioBroadcast,
+                           Unretained(LeAudioBroadcaster::Get()), is_public, broadcast_name,
+                           broadcast_code, std::move(public_metadata), std::move(subgroup_quality),
+                           std::move(subgroup_metadata)));
   }
 
   void UpdateMetadata(uint32_t broadcast_id, std::string broadcast_name,
                       std::vector<uint8_t> public_metadata,
                       std::vector<std::vector<uint8_t>> subgroup_metadata) override {
-    do_in_main_thread(FROM_HERE,
-                      Bind(&LeAudioBroadcaster::UpdateMetadata,
+    do_in_main_thread(Bind(&LeAudioBroadcaster::UpdateMetadata,
                            Unretained(LeAudioBroadcaster::Get()), broadcast_id, broadcast_name,
                            std::move(public_metadata), std::move(subgroup_metadata)));
   }
 
   void StartBroadcast(uint32_t broadcast_id) override {
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::StartAudioBroadcast,
-                                      Unretained(LeAudioBroadcaster::Get()), broadcast_id));
+    do_in_main_thread(Bind(&LeAudioBroadcaster::StartAudioBroadcast,
+                           Unretained(LeAudioBroadcaster::Get()), broadcast_id));
   }
 
   void StopBroadcast(uint32_t broadcast_id) override {
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::StopAudioBroadcast,
-                                      Unretained(LeAudioBroadcaster::Get()), broadcast_id));
+    do_in_main_thread(Bind(&LeAudioBroadcaster::StopAudioBroadcast,
+                           Unretained(LeAudioBroadcaster::Get()), broadcast_id));
   }
 
   void PauseBroadcast(uint32_t broadcast_id) override {
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::SuspendAudioBroadcast,
-                                      Unretained(LeAudioBroadcaster::Get()), broadcast_id));
+    do_in_main_thread(Bind(&LeAudioBroadcaster::SuspendAudioBroadcast,
+                           Unretained(LeAudioBroadcaster::Get()), broadcast_id));
   }
 
   void DestroyBroadcast(uint32_t broadcast_id) override {
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::DestroyAudioBroadcast,
-                                      Unretained(LeAudioBroadcaster::Get()), broadcast_id));
+    do_in_main_thread(Bind(&LeAudioBroadcaster::DestroyAudioBroadcast,
+                           Unretained(LeAudioBroadcaster::Get()), broadcast_id));
   }
 
   void GetBroadcastMetadata(uint32_t broadcast_id) override {
-    do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::GetBroadcastMetadata,
-                                      Unretained(LeAudioBroadcaster::Get()), broadcast_id));
+    do_in_main_thread(Bind(&LeAudioBroadcaster::GetBroadcastMetadata,
+                           Unretained(LeAudioBroadcaster::Get()), broadcast_id));
   }
 
   void OnBroadcastCreated(uint32_t broadcast_id, bool success) override {
@@ -113,9 +111,9 @@ class LeAudioBroadcasterInterfaceImpl : public LeAudioBroadcasterInterface,
                           Unretained(callbacks_), broadcast_id, broadcast_metadata));
   }
 
-  void Stop(void) override { do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::Stop)); }
+  void Stop(void) override { do_in_main_thread(Bind(&LeAudioBroadcaster::Stop)); }
 
-  void Cleanup(void) override { do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::Cleanup)); }
+  void Cleanup(void) override { do_in_main_thread(Bind(&LeAudioBroadcaster::Cleanup)); }
 
 private:
   LeAudioBroadcasterCallbacks* callbacks_;
diff --git a/system/btif/src/btif_pan.cc b/system/btif/src/btif_pan.cc
index aef43b0d37..215c30ff12 100644
--- a/system/btif/src/btif_pan.cc
+++ b/system/btif/src/btif_pan.cc
@@ -363,7 +363,7 @@ void btpan_set_flow_control(bool enable) {
   btpan_cb.flow = enable;
   if (enable) {
     btsock_thread_add_fd(pan_pth, btpan_cb.tap_fd, 0, SOCK_THREAD_FD_RD, 0);
-    do_in_main_thread(FROM_HERE, base::BindOnce(btu_exec_tap_fd_read, btpan_cb.tap_fd));
+    do_in_main_thread(base::BindOnce(btu_exec_tap_fd_read, btpan_cb.tap_fd));
   }
 }
 
@@ -770,6 +770,6 @@ static void btpan_tap_fd_signaled(int fd, int type, int flags, uint32_t user_id)
     btpan_tap_close(fd);
     btif_pan_close_all_conns();
   } else if (flags & SOCK_THREAD_FD_RD) {
-    do_in_main_thread(FROM_HERE, base::BindOnce(btu_exec_tap_fd_read, fd));
+    do_in_main_thread(base::BindOnce(btu_exec_tap_fd_read, fd));
   }
 }
diff --git a/system/btif/src/btif_profile_storage.cc b/system/btif/src/btif_profile_storage.cc
index 8fdb2d3056..ab31a63afb 100644
--- a/system/btif/src/btif_profile_storage.cc
+++ b/system/btif/src/btif_profile_storage.cc
@@ -549,8 +549,7 @@ void btif_storage_load_bonded_hearing_aids() {
     }
 
     // add extracted information to BTA Hearing Aid
-    do_in_main_thread(FROM_HERE,
-                      Bind(&HearingAid::AddFromStorage,
+    do_in_main_thread(Bind(&HearingAid::AddFromStorage,
                            HearingDevice(bd_addr, capabilities, codecs, audio_control_point_handle,
                                          audio_status_handle, audio_status_ccc_handle,
                                          service_changed_ccc_handle, volume_handle, read_psm_handle,
@@ -798,8 +797,7 @@ void btif_storage_load_bonded_leaudio() {
       btif_config_get_bin(name, BTIF_STORAGE_KEY_LEAUDIO_ASES_BIN, ases.data(), &buffer_size);
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&LeAudioClient::AddFromStorage, bd_addr, autoconnect,
+    do_in_main_thread(Bind(&LeAudioClient::AddFromStorage, bd_addr, autoconnect,
                            sink_audio_location, source_audio_location, sink_supported_context_type,
                            source_supported_context_type, std::move(handles), std::move(sink_pacs),
                            std::move(source_pacs), std::move(ases)));
@@ -890,8 +888,8 @@ void btif_storage_load_bonded_leaudio_has_devices() {
       features = value;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&bluetooth::le_audio::has::HasClient::AddFromStorage, bd_addr,
-                                      features, is_acceptlisted));
+    do_in_main_thread(Bind(&bluetooth::le_audio::has::HasClient::AddFromStorage, bd_addr, features,
+                           is_acceptlisted));
 #else
     log::fatal("TODO - Fix LE audio build.");
 #endif
@@ -980,7 +978,7 @@ void btif_storage_load_bonded_groups(void) {
 
     std::vector<uint8_t> in(buffer_size);
     if (btif_config_get_bin(name, BTIF_STORAGE_KEY_DEVICE_GROUP_BIN, in.data(), &buffer_size)) {
-      do_in_main_thread(FROM_HERE, Bind(&DeviceGroups::AddFromStorage, bd_addr, std::move(in)));
+      do_in_main_thread(Bind(&DeviceGroups::AddFromStorage, bd_addr, std::move(in)));
     }
   }
 }
@@ -991,7 +989,7 @@ void btif_storage_load_bonded_volume_control_devices(void) {
     auto device = bd_addr.ToString();
     if (btif_device_supports_profile(device,
                                      Uuid::From16Bit(UUID_SERVCLASS_VOLUME_CONTROL_SERVER))) {
-      do_in_main_thread(FROM_HERE, Bind(&VolumeControl::AddFromStorage, bd_addr));
+      do_in_main_thread(Bind(&VolumeControl::AddFromStorage, bd_addr));
     }
   }
 }
@@ -1026,7 +1024,7 @@ void btif_storage_load_bonded_csis_devices(void) {
     }
 
     if (buffer_size != 0) {
-      do_in_main_thread(FROM_HERE, Bind(&CsisClient::AddFromStorage, bd_addr, std::move(in)));
+      do_in_main_thread(Bind(&CsisClient::AddFromStorage, bd_addr, std::move(in)));
     }
   }
 }
diff --git a/system/btif/src/btif_vc.cc b/system/btif/src/btif_vc.cc
index 8a1fd4e2c8..150141f118 100644
--- a/system/btif/src/btif_vc.cc
+++ b/system/btif/src/btif_vc.cc
@@ -46,7 +46,6 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
   void Init(VolumeControlCallbacks* callbacks) override {
     this->callbacks_ = callbacks;
     do_in_main_thread(
-            FROM_HERE,
             Bind(&VolumeControl::Initialize, this,
                  jni_thread_wrapper(Bind(&btif_storage_load_bonded_volume_control_devices))));
 
@@ -107,8 +106,7 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&VolumeControl::Connect, Unretained(VolumeControl::Get()), address));
+    do_in_main_thread(Bind(&VolumeControl::Connect, Unretained(VolumeControl::Get()), address));
   }
 
   void Disconnect(const RawAddress& address) override {
@@ -118,8 +116,7 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
               "being not read");
       return;
     }
-    do_in_main_thread(FROM_HERE,
-                      Bind(&VolumeControl::Disconnect, Unretained(VolumeControl::Get()), address));
+    do_in_main_thread(Bind(&VolumeControl::Disconnect, Unretained(VolumeControl::Get()), address));
   }
 
   void SetVolume(std::variant<RawAddress, int> addr_or_group_id, uint8_t volume) override {
@@ -130,8 +127,8 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&VolumeControl::SetVolume, Unretained(VolumeControl::Get()),
-                                      std::move(addr_or_group_id), volume));
+    do_in_main_thread(Bind(&VolumeControl::SetVolume, Unretained(VolumeControl::Get()),
+                           std::move(addr_or_group_id), volume));
   }
 
   void Mute(std::variant<RawAddress, int> addr_or_group_id) override {
@@ -142,8 +139,8 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&VolumeControl::Mute, Unretained(VolumeControl::Get()),
-                                      std::move(addr_or_group_id)));
+    do_in_main_thread(Bind(&VolumeControl::Mute, Unretained(VolumeControl::Get()),
+                           std::move(addr_or_group_id)));
   }
 
   void Unmute(std::variant<RawAddress, int> addr_or_group_id) override {
@@ -154,8 +151,8 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&VolumeControl::UnMute, Unretained(VolumeControl::Get()),
-                                      std::move(addr_or_group_id)));
+    do_in_main_thread(Bind(&VolumeControl::UnMute, Unretained(VolumeControl::Get()),
+                           std::move(addr_or_group_id)));
   }
 
   void RemoveDevice(const RawAddress& address) override {
@@ -168,8 +165,7 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
 
     /* RemoveDevice can be called on devices that don't have HA enabled */
     if (VolumeControl::IsVolumeControlRunning()) {
-      do_in_main_thread(FROM_HERE,
-                        Bind(&VolumeControl::Remove, Unretained(VolumeControl::Get()), address));
+      do_in_main_thread(Bind(&VolumeControl::Remove, Unretained(VolumeControl::Get()), address));
     }
   }
 
@@ -181,8 +177,8 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&VolumeControl::GetExtAudioOutVolumeOffset,
-                                      Unretained(VolumeControl::Get()), address, ext_output_id));
+    do_in_main_thread(Bind(&VolumeControl::GetExtAudioOutVolumeOffset,
+                           Unretained(VolumeControl::Get()), address, ext_output_id));
   }
 
   void SetExtAudioOutVolumeOffset(const RawAddress& address, uint8_t ext_output_id,
@@ -194,8 +190,7 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&VolumeControl::SetExtAudioOutVolumeOffset,
+    do_in_main_thread(Bind(&VolumeControl::SetExtAudioOutVolumeOffset,
                            Unretained(VolumeControl::Get()), address, ext_output_id, offset_val));
   }
 
@@ -207,8 +202,8 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&VolumeControl::GetExtAudioOutLocation,
-                                      Unretained(VolumeControl::Get()), address, ext_output_id));
+    do_in_main_thread(Bind(&VolumeControl::GetExtAudioOutLocation, Unretained(VolumeControl::Get()),
+                           address, ext_output_id));
   }
 
   void SetExtAudioOutLocation(const RawAddress& address, uint8_t ext_output_id,
@@ -220,8 +215,7 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&VolumeControl::SetExtAudioOutLocation, Unretained(VolumeControl::Get()),
+    do_in_main_thread(Bind(&VolumeControl::SetExtAudioOutLocation, Unretained(VolumeControl::Get()),
                            address, ext_output_id, location));
   }
 
@@ -233,8 +227,8 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE, Bind(&VolumeControl::GetExtAudioOutDescription,
-                                      Unretained(VolumeControl::Get()), address, ext_output_id));
+    do_in_main_thread(Bind(&VolumeControl::GetExtAudioOutDescription,
+                           Unretained(VolumeControl::Get()), address, ext_output_id));
   }
 
   void SetExtAudioOutDescription(const RawAddress& address, uint8_t ext_output_id,
@@ -246,8 +240,7 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
       return;
     }
 
-    do_in_main_thread(FROM_HERE,
-                      Bind(&VolumeControl::SetExtAudioOutDescription,
+    do_in_main_thread(Bind(&VolumeControl::SetExtAudioOutDescription,
                            Unretained(VolumeControl::Get()), address, ext_output_id, descr));
   }
 
@@ -260,7 +253,7 @@ class VolumeControlInterfaceImpl : public VolumeControlInterface, public VolumeC
     }
 
     initialized = false;
-    do_in_main_thread(FROM_HERE, Bind(&VolumeControl::CleanUp));
+    do_in_main_thread(Bind(&VolumeControl::CleanUp));
   }
 
 private:
diff --git a/system/btif/src/stack_manager.cc b/system/btif/src/stack_manager.cc
index 3956a3632f..29ae9484f3 100644
--- a/system/btif/src/stack_manager.cc
+++ b/system/btif/src/stack_manager.cc
@@ -349,12 +349,12 @@ static void event_shut_down_stack(ProfileStopCallback stopProfiles) {
     module_shut_down(get_local_module(RUST_MODULE));
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(&btm_ble_scanner_cleanup));
+  do_in_main_thread(base::BindOnce(&btm_ble_scanner_cleanup));
 
   btif_dm_on_disable();
   stopProfiles();
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_dm_disable));
+  do_in_main_thread(base::BindOnce(bta_dm_disable));
 
   btif_dm_cleanup();
 
diff --git a/system/btif/test/btif_core_test.cc b/system/btif/test/btif_core_test.cc
index 759d308500..92ba0af4d1 100644
--- a/system/btif/test/btif_core_test.cc
+++ b/system/btif/test/btif_core_test.cc
@@ -764,18 +764,16 @@ TEST_F(BtifCoreWithControllerTest, debug_dump_unconfigured) {
   auto reading_promise = std::make_unique<std::promise<void>>();
   auto reading_done = reading_promise->get_future();
 
-  do_in_main_thread(FROM_HERE, BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
-  do_in_main_thread(FROM_HERE, BindOnce(
-                                       [](std::unique_ptr<std::promise<void>> done_promise) {
-                                         char line_buf[1024] = "";
-                                         int bytes_read = read(read_fd, line_buf, 1024);
-                                         EXPECT_GT(bytes_read, 0);
-                                         EXPECT_NE(
-                                                 std::string(line_buf).find("Event queue is empty"),
-                                                 std::string::npos);
-                                         done_promise->set_value();
-                                       },
-                                       std::move(reading_promise)));
+  do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
+  do_in_main_thread(BindOnce(
+          [](std::unique_ptr<std::promise<void>> done_promise) {
+            char line_buf[1024] = "";
+            int bytes_read = read(read_fd, line_buf, 1024);
+            EXPECT_GT(bytes_read, 0);
+            EXPECT_NE(std::string(line_buf).find("Event queue is empty"), std::string::npos);
+            done_promise->set_value();
+          },
+          std::move(reading_promise)));
   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
   close(write_fd);
   close(read_fd);
@@ -824,8 +822,7 @@ protected:
             .RetiresOnSaturation();
     EXPECT_CALL(hci_, RegisterVendorSpecificEventHandler(VseSubeventCode::BQR_EVENT, _))
             .WillOnce(SaveArg<1>(&this->vse_callback_));
-    do_in_main_thread(FROM_HERE,
-                      BindOnce([]() { bluetooth::bqr::EnableBtQualityReport(get_main()); }));
+    do_in_main_thread(BindOnce([]() { bluetooth::bqr::EnableBtQualityReport(get_main()); }));
     ASSERT_EQ(std::future_status::ready, configuration_done.wait_for(std::chrono::seconds(1)));
   }
 
@@ -838,8 +835,7 @@ protected:
                 EnqueueCommand(_, Matcher<ContextualOnceCallback<void(CommandCompleteView)>>(_)))
             .WillOnce(Invoke(set_promise))
             .RetiresOnSaturation();
-    do_in_main_thread(FROM_HERE,
-                      BindOnce([]() { bluetooth::bqr::EnableBtQualityReport(nullptr); }));
+    do_in_main_thread(BindOnce([]() { bluetooth::bqr::EnableBtQualityReport(nullptr); }));
     ASSERT_EQ(std::future_status::ready, disable_future.wait_for(std::chrono::seconds(1)));
 
     bluetooth::hci::testing::mock_hci_layer_ = nullptr;
@@ -901,18 +897,16 @@ TEST_F(BtifCoreVseWithSocketTest, debug_dump_empty) {
   auto reading_promise = std::make_unique<std::promise<void>>();
   auto reading_done = reading_promise->get_future();
 
-  do_in_main_thread(FROM_HERE, BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
-  do_in_main_thread(FROM_HERE, BindOnce(
-                                       [](std::unique_ptr<std::promise<void>> done_promise) {
-                                         char line_buf[1024] = "";
-                                         int bytes_read = read(read_fd, line_buf, 1024);
-                                         EXPECT_GT(bytes_read, 0);
-                                         EXPECT_NE(
-                                                 std::string(line_buf).find("Event queue is empty"),
-                                                 std::string::npos);
-                                         done_promise->set_value();
-                                       },
-                                       std::move(reading_promise)));
+  do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
+  do_in_main_thread(BindOnce(
+          [](std::unique_ptr<std::promise<void>> done_promise) {
+            char line_buf[1024] = "";
+            int bytes_read = read(read_fd, line_buf, 1024);
+            EXPECT_GT(bytes_read, 0);
+            EXPECT_NE(std::string(line_buf).find("Event queue is empty"), std::string::npos);
+            done_promise->set_value();
+          },
+          std::move(reading_promise)));
   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
 }
 
@@ -932,22 +926,21 @@ TEST_F(BtifCoreVseWithSocketTest, send_lmp_ll_msg) {
   auto reading_done = reading_promise->get_future();
 
   static int write_fd = write_fd_;
-  do_in_main_thread(FROM_HERE,
-                    BindOnce([]() { bluetooth::bqr::testing::set_lmp_trace_log_fd(write_fd); }));
+  do_in_main_thread(BindOnce([]() { bluetooth::bqr::testing::set_lmp_trace_log_fd(write_fd); }));
   vse_callback_(view);
 
-  do_in_main_thread(FROM_HERE, BindOnce(
-                                       [](std::unique_ptr<std::promise<void>> done_promise) {
-                                         char line_buf[1024] = "";
-                                         std::string line;
-                                         int bytes_read = read(read_fd, line_buf, 1024);
-                                         EXPECT_GT(bytes_read, 0);
-                                         line = std::string(line_buf);
-                                         EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
-                                         EXPECT_NE(line.find("data"), std::string::npos);
-                                         done_promise->set_value();
-                                       },
-                                       std::move(reading_promise)));
+  do_in_main_thread(BindOnce(
+          [](std::unique_ptr<std::promise<void>> done_promise) {
+            char line_buf[1024] = "";
+            std::string line;
+            int bytes_read = read(read_fd, line_buf, 1024);
+            EXPECT_GT(bytes_read, 0);
+            line = std::string(line_buf);
+            EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
+            EXPECT_NE(line.find("data"), std::string::npos);
+            done_promise->set_value();
+          },
+          std::move(reading_promise)));
   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
 }
 
@@ -966,22 +959,21 @@ TEST_F(BtifCoreVseWithSocketTest, debug_dump_a2dp_choppy_no_payload) {
   auto reading_promise = std::make_unique<std::promise<void>>();
   auto reading_done = reading_promise->get_future();
 
-  do_in_main_thread(FROM_HERE, BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
-  do_in_main_thread(FROM_HERE, BindOnce(
-                                       [](std::unique_ptr<std::promise<void>> done_promise) {
-                                         char line_buf[1024] = "";
-                                         std::string line;
-                                         int bytes_read = read(read_fd, line_buf, 1024);
-                                         EXPECT_GT(bytes_read, 0);
-                                         line = std::string(line_buf);
-                                         EXPECT_EQ(line.find("Event queue is empty"),
-                                                   std::string::npos);
-                                         EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
-                                         EXPECT_NE(line.find("UndFlow: 15"), std::string::npos);
-                                         EXPECT_NE(line.find("A2DP Choppy"), std::string::npos);
-                                         done_promise->set_value();
-                                       },
-                                       std::move(reading_promise)));
+  do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
+  do_in_main_thread(BindOnce(
+          [](std::unique_ptr<std::promise<void>> done_promise) {
+            char line_buf[1024] = "";
+            std::string line;
+            int bytes_read = read(read_fd, line_buf, 1024);
+            EXPECT_GT(bytes_read, 0);
+            line = std::string(line_buf);
+            EXPECT_EQ(line.find("Event queue is empty"), std::string::npos);
+            EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
+            EXPECT_NE(line.find("UndFlow: 15"), std::string::npos);
+            EXPECT_NE(line.find("A2DP Choppy"), std::string::npos);
+            done_promise->set_value();
+          },
+          std::move(reading_promise)));
   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
 }
 
@@ -1000,21 +992,20 @@ TEST_F(BtifCoreVseWithSocketTest, debug_dump_a2dp_choppy) {
   auto reading_promise = std::make_unique<std::promise<void>>();
   auto reading_done = reading_promise->get_future();
 
-  do_in_main_thread(FROM_HERE, BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
-  do_in_main_thread(FROM_HERE, BindOnce(
-                                       [](std::unique_ptr<std::promise<void>> done_promise) {
-                                         char line_buf[1024] = "";
-                                         std::string line;
-                                         int bytes_read = read(read_fd, line_buf, 1024);
-                                         EXPECT_GT(bytes_read, 0);
-                                         line = std::string(line_buf);
-                                         EXPECT_EQ(line.find("Event queue is empty"),
-                                                   std::string::npos);
-                                         EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
-                                         EXPECT_NE(line.find("UndFlow: 15"), std::string::npos);
-                                         EXPECT_NE(line.find("A2DP Choppy"), std::string::npos);
-                                         done_promise->set_value();
-                                       },
-                                       std::move(reading_promise)));
+  do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
+  do_in_main_thread(BindOnce(
+          [](std::unique_ptr<std::promise<void>> done_promise) {
+            char line_buf[1024] = "";
+            std::string line;
+            int bytes_read = read(read_fd, line_buf, 1024);
+            EXPECT_GT(bytes_read, 0);
+            line = std::string(line_buf);
+            EXPECT_EQ(line.find("Event queue is empty"), std::string::npos);
+            EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
+            EXPECT_NE(line.find("UndFlow: 15"), std::string::npos);
+            EXPECT_NE(line.find("A2DP Choppy"), std::string::npos);
+            done_promise->set_value();
+          },
+          std::move(reading_promise)));
   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
 }
diff --git a/system/gd/module_gdx_unittest.cc b/system/gd/module_gdx_unittest.cc
index 76eefd8610..a744e176ab 100644
--- a/system/gd/module_gdx_unittest.cc
+++ b/system/gd/module_gdx_unittest.cc
@@ -441,12 +441,12 @@ TEST_F(ModuleGdxWithInstrumentedCallback, test_call_callback_on_handler) {
   // Enqueue something else on the main thread and verify that it hasn't run
   static auto second_task_promise = std::promise<void>();
   auto final_future = second_task_promise.get_future();
-  do_in_main_thread(FROM_HERE, common::BindOnce(
-                                       [](std::promise<void> promise) {
-                                         promise.set_value();
-                                         log::info("Finally");
-                                       },
-                                       std::move(second_task_promise)));
+  do_in_main_thread(common::BindOnce(
+          [](std::promise<void> promise) {
+            promise.set_value();
+            log::info("Finally");
+          },
+          std::move(second_task_promise)));
   ASSERT_EQ(std::future_status::timeout, final_future.wait_for(std::chrono::milliseconds(1)));
 
   // Let the callback start
@@ -473,12 +473,12 @@ TEST_F(ModuleGdxWithInstrumentedCallback, test_call_once_callback_on_handler) {
   // Enqueue something else on the main thread and verify that it hasn't run
   static auto second_task_promise = std::promise<void>();
   auto final_future = second_task_promise.get_future();
-  do_in_main_thread(FROM_HERE, common::BindOnce(
-                                       [](std::promise<void> promise) {
-                                         promise.set_value();
-                                         log::info("Finally");
-                                       },
-                                       std::move(second_task_promise)));
+  do_in_main_thread(common::BindOnce(
+          [](std::promise<void> promise) {
+            promise.set_value();
+            log::info("Finally");
+          },
+          std::move(second_task_promise)));
   ASSERT_EQ(std::future_status::timeout, final_future.wait_for(std::chrono::milliseconds(1)));
 
   // Let the callback start
@@ -505,12 +505,12 @@ TEST_F(ModuleGdxWithInstrumentedCallback, test_call_callback_on_main) {
   // Enqueue something else on the main thread and verify that it hasn't run
   static auto second_task_promise = std::promise<void>();
   auto final_future = second_task_promise.get_future();
-  do_in_main_thread(FROM_HERE, common::BindOnce(
-                                       [](std::promise<void> promise) {
-                                         promise.set_value();
-                                         log::info("Finally");
-                                       },
-                                       std::move(second_task_promise)));
+  do_in_main_thread(common::BindOnce(
+          [](std::promise<void> promise) {
+            promise.set_value();
+            log::info("Finally");
+          },
+          std::move(second_task_promise)));
   ASSERT_EQ(std::future_status::timeout, final_future.wait_for(std::chrono::milliseconds(1)));
 
   // Let the callback start
@@ -537,12 +537,12 @@ TEST_F(ModuleGdxWithInstrumentedCallback, test_call_once_callback_on_main) {
   // Enqueue something else on the main thread and verify that it hasn't run
   static auto second_task_promise = std::promise<void>();
   auto final_future = second_task_promise.get_future();
-  do_in_main_thread(FROM_HERE, common::BindOnce(
-                                       [](std::promise<void> promise) {
-                                         promise.set_value();
-                                         log::info("Finally");
-                                       },
-                                       std::move(second_task_promise)));
+  do_in_main_thread(common::BindOnce(
+          [](std::promise<void> promise) {
+            promise.set_value();
+            log::info("Finally");
+          },
+          std::move(second_task_promise)));
   ASSERT_EQ(std::future_status::timeout, final_future.wait_for(std::chrono::milliseconds(1)));
 
   // Let the callback start
@@ -569,12 +569,12 @@ TEST_F(ModuleGdxWithInstrumentedCallback, test_call_callback_on_jni) {
   // Enqueue something else on the main thread and verify that it hasn't run
   static auto second_task_promise = std::promise<void>();
   auto final_future = second_task_promise.get_future();
-  do_in_main_thread(FROM_HERE, common::BindOnce(
-                                       [](std::promise<void> promise) {
-                                         promise.set_value();
-                                         log::info("Finally");
-                                       },
-                                       std::move(second_task_promise)));
+  do_in_main_thread(common::BindOnce(
+          [](std::promise<void> promise) {
+            promise.set_value();
+            log::info("Finally");
+          },
+          std::move(second_task_promise)));
   ASSERT_EQ(std::future_status::timeout, final_future.wait_for(std::chrono::milliseconds(1)));
 
   // Let the callback start
@@ -601,12 +601,12 @@ TEST_F(ModuleGdxWithInstrumentedCallback, test_call_once_callback_on_jni) {
   // Enqueue something else on the main thread and verify that it hasn't run
   static auto second_task_promise = std::promise<void>();
   auto final_future = second_task_promise.get_future();
-  do_in_main_thread(FROM_HERE, common::BindOnce(
-                                       [](std::promise<void> promise) {
-                                         promise.set_value();
-                                         log::info("Finally");
-                                       },
-                                       std::move(second_task_promise)));
+  do_in_main_thread(common::BindOnce(
+          [](std::promise<void> promise) {
+            promise.set_value();
+            log::info("Finally");
+          },
+          std::move(second_task_promise)));
   ASSERT_EQ(std::future_status::timeout, final_future.wait_for(std::chrono::milliseconds(1)));
 
   // Let the callback start
diff --git a/system/gd/module_mainloop.h b/system/gd/module_mainloop.h
index ce6ed8c1cb..9f07e89ef6 100644
--- a/system/gd/module_mainloop.h
+++ b/system/gd/module_mainloop.h
@@ -33,24 +33,20 @@ protected:
   // Threadsafe post onto mainloop a function with copyable arguments
   template <typename Functor, typename... Args>
   void PostFunctionOnMain(Functor&& functor, Args&&... args) const {
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(std::forward<Functor>(functor), std::forward<Args>(args)...));
+    do_in_main_thread(base::BindOnce(std::forward<Functor>(functor), std::forward<Args>(args)...));
   }
 
   // Threadsafe post onto mainloop a method and context with copyable arguments
   template <typename T, typename Functor, typename... Args>
   void PostMethodOnMain(std::shared_ptr<T> ref, Functor&& functor, Args... args) const {
-    do_in_main_thread(FROM_HERE,
-                      base::BindOnce(
-                              [](std::weak_ptr<T> ref, Functor&& functor, Args&&... args) {
-                                if (std::shared_ptr<T> spt = ref.lock()) {
-                                  base::BindOnce(std::forward<Functor>(functor), spt,
-                                                 std::forward<Args>(args)...)
-                                          .Run();
-                                }
-                              },
-                              std::weak_ptr<T>(ref), std::forward<Functor>(functor),
-                              std::forward<Args>(args)...));
+    do_in_main_thread(base::BindOnce(
+            [](std::weak_ptr<T> ref, Functor&& functor, Args&&... args) {
+              if (std::shared_ptr<T> spt = ref.lock()) {
+                base::BindOnce(std::forward<Functor>(functor), spt, std::forward<Args>(args)...)
+                        .Run();
+              }
+            },
+            std::weak_ptr<T>(ref), std::forward<Functor>(functor), std::forward<Args>(args)...));
   }
 };
 
diff --git a/system/main/shim/acl.cc b/system/main/shim/acl.cc
index 7ba293bc4e..4529574dd4 100644
--- a/system/main/shim/acl.cc
+++ b/system/main/shim/acl.cc
@@ -350,13 +350,13 @@ void ValidateAclInterface(const shim::legacy::acl_interface_t& acl_interface) {
 
 }  // namespace
 
-#define TRY_POSTING_ON_MAIN(cb, ...)                                   \
-  do {                                                                 \
-    if (cb == nullptr) {                                               \
-      log::warn("Dropping ACL event with no callback");                \
-    } else {                                                           \
-      do_in_main_thread(FROM_HERE, base::BindOnce(cb, ##__VA_ARGS__)); \
-    }                                                                  \
+#define TRY_POSTING_ON_MAIN(cb, ...)                        \
+  do {                                                      \
+    if (cb == nullptr) {                                    \
+      log::warn("Dropping ACL event with no callback");     \
+    } else {                                                \
+      do_in_main_thread(base::BindOnce(cb, ##__VA_ARGS__)); \
+    }                                                       \
   } while (0)
 
 constexpr HciHandle kInvalidHciHandle = 0xffff;
@@ -415,8 +415,7 @@ public:
     if (send_data_upwards_ == nullptr) {
       log::warn("Dropping ACL data with no callback");
       osi_free(p_buf);
-    } else if (do_in_main_thread(FROM_HERE, base::BindOnce(send_data_upwards_, p_buf)) !=
-               BT_STATUS_SUCCESS) {
+    } else if (do_in_main_thread(base::BindOnce(send_data_upwards_, p_buf)) != BT_STATUS_SUCCESS) {
       osi_free(p_buf);
     }
   }
diff --git a/system/main/shim/acl_api.cc b/system/main/shim/acl_api.cc
index 78e95c8b9d..5ea1247a1f 100644
--- a/system/main/shim/acl_api.cc
+++ b/system/main/shim/acl_api.cc
@@ -196,35 +196,31 @@ void bluetooth::shim::ACL_RemoteNameRequest(const RawAddress& addr, uint8_t page
                                                           : hci::ClockOffsetValid::INVALID),
           GetGdShimHandler()->BindOnce([](hci::ErrorCode status) {
             if (status != hci::ErrorCode::SUCCESS) {
-              do_in_main_thread(FROM_HERE, base::BindOnce(
-                                                   [](hci::ErrorCode status) {
-                                                     // NOTE: we intentionally don't supply the
-                                                     // address, to match the legacy behavior.
-                                                     // Callsites that want the address should use
-                                                     // StartRemoteNameRequest() directly, rather
-                                                     // than going through this shim.
-                                                     btm_process_remote_name(
-                                                             nullptr, nullptr, 0,
-                                                             static_cast<tHCI_STATUS>(status));
-                                                     btm_sec_rmt_name_request_complete(
-                                                             nullptr, nullptr,
-                                                             static_cast<tHCI_STATUS>(status));
-                                                   },
-                                                   status));
+              do_in_main_thread(base::BindOnce(
+                      [](hci::ErrorCode status) {
+                        // NOTE: we intentionally don't supply the
+                        // address, to match the legacy behavior.
+                        // Callsites that want the address should use
+                        // StartRemoteNameRequest() directly, rather
+                        // than going through this shim.
+                        btm_process_remote_name(nullptr, nullptr, 0,
+                                                static_cast<tHCI_STATUS>(status));
+                        btm_sec_rmt_name_request_complete(nullptr, nullptr,
+                                                          static_cast<tHCI_STATUS>(status));
+                      },
+                      status));
             }
           }),
           GetGdShimHandler()->BindOnce(
                   [](RawAddress addr, uint64_t features) {
                     static_assert(sizeof(features) == 8);
-                    do_in_main_thread(FROM_HERE,
-                                      base::BindOnce(btm_sec_rmt_host_support_feat_evt, addr,
+                    do_in_main_thread(base::BindOnce(btm_sec_rmt_host_support_feat_evt, addr,
                                                      static_cast<uint8_t>(features & 0xff)));
                   },
                   addr),
           GetGdShimHandler()->BindOnce(
                   [](RawAddress addr, hci::ErrorCode status, std::array<uint8_t, 248> name) {
                     do_in_main_thread(
-                            FROM_HERE,
                             base::BindOnce(
                                     [](RawAddress addr, hci::ErrorCode status,
                                        std::array<uint8_t, 248> name) {
diff --git a/system/main/shim/le_advertising_manager.cc b/system/main/shim/le_advertising_manager.cc
index 645f02633b..946c9f80a4 100644
--- a/system/main/shim/le_advertising_manager.cc
+++ b/system/main/shim/le_advertising_manager.cc
@@ -65,8 +65,7 @@ public:
     bluetooth::shim::GetAdvertising()->RegisterAdvertiser(
             bluetooth::shim::GetGdShimHandler()->BindOnce(
                     [](IdStatusCallback cb, uint8_t id, uint8_t status) {
-                      do_in_main_thread(FROM_HERE,
-                                        base::BindOnce([](IdStatusCallback cb, uint8_t id,
+                      do_in_main_thread(base::BindOnce([](IdStatusCallback cb, uint8_t id,
                                                           uint8_t status) { cb.Run(id, status); },
                                                        cb, id, status));
                     },
@@ -219,8 +218,7 @@ public:
     uint8_t client_id = is_native_advertiser(reg_id);
     if (client_id != kAdvertiserClientIdJni) {
       // Invoke callback for native client
-      do_in_main_thread(FROM_HERE,
-                        base::Bind(&AdvertisingCallbacks::OnAdvertisingSetStarted,
+      do_in_main_thread(base::Bind(&AdvertisingCallbacks::OnAdvertisingSetStarted,
                                    base::Unretained(native_adv_callbacks_map_[client_id]), reg_id,
                                    advertiser_id, tx_power, status));
       return;
@@ -235,8 +233,7 @@ public:
     uint8_t client_id = is_native_advertiser(reg_id);
     if (client_id != kAdvertiserClientIdJni) {
       // Invoke callback for native client
-      do_in_main_thread(FROM_HERE,
-                        base::Bind(&AdvertisingCallbacks::OnAdvertisingEnabled,
+      do_in_main_thread(base::Bind(&AdvertisingCallbacks::OnAdvertisingEnabled,
                                    base::Unretained(native_adv_callbacks_map_[client_id]),
                                    advertiser_id, enable, status));
       return;
@@ -252,8 +249,7 @@ public:
       uint8_t client_id = is_native_advertiser(reg_id);
       if (client_id != kAdvertiserClientIdJni) {
         // Invoke callback for native client
-        do_in_main_thread(FROM_HERE,
-                          base::Bind(&AdvertisingCallbacks::OnAdvertisingDataSet,
+        do_in_main_thread(base::Bind(&AdvertisingCallbacks::OnAdvertisingDataSet,
                                      base::Unretained(native_adv_callbacks_map_[client_id]),
                                      advertiser_id, status));
         return;
@@ -289,8 +285,7 @@ public:
       uint8_t client_id = is_native_advertiser(reg_id);
       if (client_id != kAdvertiserClientIdJni) {
         // Invoke callback for native client
-        do_in_main_thread(FROM_HERE,
-                          base::Bind(&AdvertisingCallbacks::OnPeriodicAdvertisingDataSet,
+        do_in_main_thread(base::Bind(&AdvertisingCallbacks::OnPeriodicAdvertisingDataSet,
                                      base::Unretained(native_adv_callbacks_map_[client_id]),
                                      advertiser_id, status));
         return;
diff --git a/system/main/shim/shim.cc b/system/main/shim/shim.cc
index 3e37c888ea..018b2e7858 100644
--- a/system/main/shim/shim.cc
+++ b/system/main/shim/shim.cc
@@ -32,7 +32,7 @@ static const hci_t* hci;
 void btu_hci_msg_process(BT_HDR* p_msg);
 
 static void post_to_main_message_loop(const base::Location& from_here, BT_HDR* p_msg) {
-  if (do_in_main_thread(from_here, base::Bind(&btu_hci_msg_process, p_msg)) != BT_STATUS_SUCCESS) {
+  if (do_in_main_thread(base::Bind(&btu_hci_msg_process, p_msg)) != BT_STATUS_SUCCESS) {
     bluetooth::log::error(": do_in_main_thread failed from {}", from_here.ToString());
   }
 }
diff --git a/system/stack/acl/btm_acl.cc b/system/stack/acl/btm_acl.cc
index 4ec9d3096c..f4938acd7e 100644
--- a/system/stack/acl/btm_acl.cc
+++ b/system/stack/acl/btm_acl.cc
@@ -2017,7 +2017,7 @@ void btm_cont_rswitch_from_handle(uint16_t hci_handle) {
  *
  ******************************************************************************/
 void btm_acl_notif_conn_collision(const RawAddress& bda) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(bta_sys_notify_collision, bda));
+  do_in_main_thread(base::BindOnce(bta_sys_notify_collision, bda));
 }
 
 bool BTM_BLE_IS_RESOLVE_BDA(const RawAddress& x) {
diff --git a/system/stack/arbiter/acl_arbiter.cc b/system/stack/arbiter/acl_arbiter.cc
index 4193f34216..6fd2102810 100644
--- a/system/stack/arbiter/acl_arbiter.cc
+++ b/system/stack/arbiter/acl_arbiter.cc
@@ -135,8 +135,7 @@ void StoreCallbacksFromRust(
 }
 
 void SendPacketToPeer(uint8_t tcb_idx, ::rust::Vec<uint8_t> buffer) {
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(&AclArbiter::SendPacketToPeer, base::Unretained(&GetArbiter()),
+  do_in_main_thread(base::BindOnce(&AclArbiter::SendPacketToPeer, base::Unretained(&GetArbiter()),
                                    tcb_idx, std::move(buffer)));
 }
 
diff --git a/system/stack/btm/btm_sco.cc b/system/stack/btm/btm_sco.cc
index c5975bce6b..8be7d30547 100644
--- a/system/stack/btm/btm_sco.cc
+++ b/system/stack/btm/btm_sco.cc
@@ -111,7 +111,7 @@ static void sco_data_callback() {
     log::info("Dropping invalid packet of size {}", packet->size());
     return;
   }
-  if (do_in_main_thread(FROM_HERE, base::Bind(&btm_route_sco_data, *packet)) != BT_STATUS_SUCCESS) {
+  if (do_in_main_thread(base::Bind(&btm_route_sco_data, *packet)) != BT_STATUS_SUCCESS) {
     log::error("do_in_main_thread failed from sco_data_callback");
   }
 }
diff --git a/system/stack/btm/btm_sec.cc b/system/stack/btm/btm_sec.cc
index 4b313d8ee0..81f1fc3ed7 100644
--- a/system/stack/btm/btm_sec.cc
+++ b/system/stack/btm/btm_sec.cc
@@ -975,8 +975,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, tBT_TRANSPORT transport
                 "transport:{}",
                 bd_addr, bt_transport_text(transport));
         if (p_callback) {
-          do_in_main_thread(FROM_HERE, base::BindOnce(p_callback, bd_addr, transport, p_ref_data,
-                                                      BTM_WRONG_MODE));
+          do_in_main_thread(
+                  base::BindOnce(p_callback, bd_addr, transport, p_ref_data, BTM_WRONG_MODE));
         }
         return BTM_WRONG_MODE;
       }
@@ -986,8 +986,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, tBT_TRANSPORT transport
                 "transport:{}",
                 bd_addr, bt_transport_text(transport));
         if (p_callback) {
-          do_in_main_thread(FROM_HERE, base::BindOnce(p_callback, bd_addr, transport, p_ref_data,
-                                                      BTM_SUCCESS));
+          do_in_main_thread(
+                  base::BindOnce(p_callback, bd_addr, transport, p_ref_data, BTM_SUCCESS));
         }
         return BTM_SUCCESS;
       }
@@ -1000,8 +1000,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, tBT_TRANSPORT transport
                 "transport:{}",
                 bd_addr, bt_transport_text(transport));
         if (p_callback) {
-          do_in_main_thread(FROM_HERE, base::BindOnce(p_callback, bd_addr, transport, p_ref_data,
-                                                      BTM_WRONG_MODE));
+          do_in_main_thread(
+                  base::BindOnce(p_callback, bd_addr, transport, p_ref_data, BTM_WRONG_MODE));
         }
         return BTM_WRONG_MODE;
       }
@@ -1011,8 +1011,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, tBT_TRANSPORT transport
                 "transport:{}",
                 bd_addr, bt_transport_text(transport));
         if (p_callback) {
-          do_in_main_thread(FROM_HERE, base::BindOnce(p_callback, bd_addr, transport, p_ref_data,
-                                                      BTM_SUCCESS));
+          do_in_main_thread(
+                  base::BindOnce(p_callback, bd_addr, transport, p_ref_data, BTM_SUCCESS));
         }
         return BTM_SUCCESS;
       }
@@ -1078,8 +1078,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, tBT_TRANSPORT transport
         log::debug("Executing encryption callback peer:{} transport:{}", bd_addr,
                    bt_transport_text(transport));
         p_dev_rec->sec_rec.p_callback = nullptr;
-        do_in_main_thread(FROM_HERE, base::BindOnce(p_callback, bd_addr, transport,
-                                                    p_dev_rec->sec_rec.p_ref_data, rc));
+        do_in_main_thread(
+                base::BindOnce(p_callback, bd_addr, transport, p_dev_rec->sec_rec.p_ref_data, rc));
       }
       break;
   }
@@ -4493,9 +4493,8 @@ static void btm_sec_wait_and_start_authentication(tBTM_SEC_DEV_REC* p_dev_rec) {
     delay_auth = BTM_SEC_START_AUTH_DELAY;
   }
 
-  bt_status_t status =
-          do_in_main_thread_delayed(FROM_HERE, base::Bind(&btm_sec_auth_timer_timeout, addr),
-                                    std::chrono::milliseconds(delay_auth));
+  bt_status_t status = do_in_main_thread_delayed(base::Bind(&btm_sec_auth_timer_timeout, addr),
+                                                 std::chrono::milliseconds(delay_auth));
   if (status != BT_STATUS_SUCCESS) {
     log::error("do_in_main_thread_delayed failed. directly calling");
     btm_sec_auth_timer_timeout(addr);
diff --git a/system/stack/btu/btu_hcif.cc b/system/stack/btu/btu_hcif.cc
index 68653974cc..98cccba715 100644
--- a/system/stack/btu/btu_hcif.cc
+++ b/system/stack/btu/btu_hcif.cc
@@ -652,8 +652,8 @@ static void btu_hcif_command_complete_evt_with_cb_on_task(BT_HDR* event, void* c
 }
 
 static void btu_hcif_command_complete_evt_with_cb(BT_HDR* response, void* context) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(btu_hcif_command_complete_evt_with_cb_on_task,
-                                              response, context));
+  do_in_main_thread(
+          base::BindOnce(btu_hcif_command_complete_evt_with_cb_on_task, response, context));
 }
 
 static void btu_hcif_command_status_evt_with_cb_on_task(uint8_t status, BT_HDR* event,
@@ -685,8 +685,8 @@ static void btu_hcif_command_status_evt_with_cb(uint8_t status, BT_HDR* command,
     return;
   }
 
-  do_in_main_thread(FROM_HERE, base::BindOnce(btu_hcif_command_status_evt_with_cb_on_task, status,
-                                              command, context));
+  do_in_main_thread(
+          base::BindOnce(btu_hcif_command_status_evt_with_cb_on_task, status, command, context));
 }
 
 /* This function is called to send commands to the Host Controller. |cb| is
@@ -989,7 +989,7 @@ static void btu_hcif_command_complete_evt_on_task(BT_HDR* event) {
 }
 
 static void btu_hcif_command_complete_evt(BT_HDR* response, void* /* context */) {
-  do_in_main_thread(FROM_HERE, base::BindOnce(btu_hcif_command_complete_evt_on_task, response));
+  do_in_main_thread(base::BindOnce(btu_hcif_command_complete_evt_on_task, response));
 }
 
 /*******************************************************************************
@@ -1122,8 +1122,7 @@ static void btu_hcif_command_status_evt_on_task(uint8_t status, BT_HDR* event) {
 }
 
 static void btu_hcif_command_status_evt(uint8_t status, BT_HDR* command, void* /* context */) {
-  do_in_main_thread(FROM_HERE,
-                    base::BindOnce(btu_hcif_command_status_evt_on_task, status, command));
+  do_in_main_thread(base::BindOnce(btu_hcif_command_status_evt_on_task, status, command));
 }
 
 /*******************************************************************************
diff --git a/system/stack/btu/main_thread.cc b/system/stack/btu/main_thread.cc
index 0668223a0a..03afc210f5 100644
--- a/system/stack/btu/main_thread.cc
+++ b/system/stack/btu/main_thread.cc
@@ -37,18 +37,17 @@ static MessageLoopThread main_thread("bt_main_thread");
 bluetooth::common::MessageLoopThread* get_main_thread() { return &main_thread; }
 bluetooth::common::PostableContext* get_main() { return main_thread.Postable(); }
 
-bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure task) {
-  if (!main_thread.DoInThread(from_here, std::move(task))) {
-    log::error("failed from {}", from_here.ToString());
+bt_status_t do_in_main_thread(base::OnceClosure task) {
+  if (!main_thread.DoInThread(FROM_HERE, std::move(task))) {
+    log::error("failed to post task to task runner!");
     return BT_STATUS_JNI_THREAD_ATTACH_ERROR;
   }
   return BT_STATUS_SUCCESS;
 }
 
-bt_status_t do_in_main_thread_delayed(const base::Location& from_here, base::OnceClosure task,
-                                      std::chrono::microseconds delay) {
-  if (!main_thread.DoInThreadDelayed(from_here, std::move(task), delay)) {
-    log::error("failed from {}", from_here.ToString());
+bt_status_t do_in_main_thread_delayed(base::OnceClosure task, std::chrono::microseconds delay) {
+  if (!main_thread.DoInThreadDelayed(FROM_HERE, std::move(task), delay)) {
+    log::error("failed to post task to task runner!");
     return BT_STATUS_JNI_THREAD_ATTACH_ERROR;
   }
   return BT_STATUS_SUCCESS;
@@ -57,12 +56,11 @@ bt_status_t do_in_main_thread_delayed(const base::Location& from_here, base::Onc
 static void do_post_on_bt_main(BtMainClosure closure) { closure(); }
 
 void post_on_bt_main(BtMainClosure closure) {
-  log::assert_that(
-          do_in_main_thread(FROM_HERE, base::BindOnce(do_post_on_bt_main, std::move(closure))) ==
-                  BT_STATUS_SUCCESS,
-          "assert failed: do_in_main_thread(FROM_HERE, "
-          "base::BindOnce(do_post_on_bt_main, std::move(closure))) == "
-          "BT_STATUS_SUCCESS");
+  log::assert_that(do_in_main_thread(base::BindOnce(do_post_on_bt_main, std::move(closure))) ==
+                           BT_STATUS_SUCCESS,
+                   "assert failed: do_in_main_thread("
+                   "base::BindOnce(do_post_on_bt_main, std::move(closure))) == "
+                   "BT_STATUS_SUCCESS");
 }
 
 void main_thread_start_up() {
diff --git a/system/stack/eatt/eatt_impl.h b/system/stack/eatt/eatt_impl.h
index bc0d58617d..0014666156 100644
--- a/system/stack/eatt/eatt_impl.h
+++ b/system/stack/eatt/eatt_impl.h
@@ -242,8 +242,7 @@ struct eatt_impl {
 
   void upper_tester_delay_connect(const RawAddress& bda, int timeout_ms) {
     bt_status_t status =
-            do_in_main_thread_delayed(FROM_HERE,
-                                      base::BindOnce(&eatt_impl::upper_tester_delay_connect_cb,
+            do_in_main_thread_delayed(base::BindOnce(&eatt_impl::upper_tester_delay_connect_cb,
                                                      weak_factory_.GetWeakPtr(), bda),
                                       std::chrono::milliseconds(timeout_ms));
 
@@ -284,7 +283,6 @@ struct eatt_impl {
 
     if (stack_config_get_interface()->get_pts_l2cap_ecoc_reconfigure()) {
       bt_status_t status = do_in_main_thread_delayed(
-              FROM_HERE,
               base::BindOnce(&eatt_impl::reconfigure_all, weak_factory_.GetWeakPtr(), bda, 300),
               std::chrono::seconds(4));
       log::info("Scheduled ECOC reconfiguration with status: {}", (int)status);
@@ -431,8 +429,7 @@ struct eatt_impl {
 
     if (stack_config_get_interface()->get_pts_l2cap_ecoc_reconfigure()) {
       /* Upper tester for L2CAP - schedule sending data */
-      do_in_main_thread_delayed(FROM_HERE,
-                                base::BindOnce(&eatt_impl::upper_tester_send_data_if_needed,
+      do_in_main_thread_delayed(base::BindOnce(&eatt_impl::upper_tester_send_data_if_needed,
                                                weak_factory_.GetWeakPtr(), bda, lcid),
                                 std::chrono::seconds(1));
     }
diff --git a/system/stack/fuzzers/gatt_fuzzer.cc b/system/stack/fuzzers/gatt_fuzzer.cc
index 85dbadf2f0..a98f674e72 100644
--- a/system/stack/fuzzers/gatt_fuzzer.cc
+++ b/system/stack/fuzzers/gatt_fuzzer.cc
@@ -33,13 +33,12 @@
 #include "test/mock/mock_stack_l2cap_ble.h"
 
 using bluetooth::Uuid;
-bt_status_t do_in_main_thread(base::Location const&, base::OnceCallback<void()>) {
+bt_status_t do_in_main_thread(base::OnceCallback<void()>) {
   // this is not properly mocked, so we use abort to catch if this is used in
   // any test cases
   abort();
 }
-bt_status_t do_in_main_thread_delayed(base::Location const&, base::OnceCallback<void()>,
-                                      std::chrono::microseconds) {
+bt_status_t do_in_main_thread_delayed(base::OnceCallback<void()>, std::chrono::microseconds) {
   // this is not properly mocked, so we use abort to catch if this is used in
   // any test cases
   abort();
diff --git a/system/stack/fuzzers/l2cap_fuzzer.cc b/system/stack/fuzzers/l2cap_fuzzer.cc
index 6ec3cf65a9..dc2966fc4c 100644
--- a/system/stack/fuzzers/l2cap_fuzzer.cc
+++ b/system/stack/fuzzers/l2cap_fuzzer.cc
@@ -55,13 +55,12 @@ static void ConsumeData(const uint8_t* data, size_t size) {
 
 tBTM_CB btm_cb;
 
-bt_status_t do_in_main_thread(base::Location const&, base::OnceCallback<void()>) {
+bt_status_t do_in_main_thread(base::OnceCallback<void()>) {
   // this is not properly mocked, so we use abort to catch if this is used in
   // any test cases
   abort();
 }
-bt_status_t do_in_main_thread_delayed(base::Location const&, base::OnceCallback<void()>,
-                                      std::chrono::microseconds) {
+bt_status_t do_in_main_thread_delayed(base::OnceCallback<void()>, std::chrono::microseconds) {
   // this is not properly mocked, so we use abort to catch if this is used in
   // any test cases
   abort();
diff --git a/system/stack/gatt/connection_manager.cc b/system/stack/gatt/connection_manager.cc
index 3a955d8987..deddf506f7 100644
--- a/system/stack/gatt/connection_manager.cc
+++ b/system/stack/gatt/connection_manager.cc
@@ -179,7 +179,7 @@ static void target_announcement_observe_results_cb(tBTM_INQ_RESULTS* p_inq, cons
   auto app_id = *(it->second.doing_targeted_announcements_conn.begin());
 
   /* If scan is ongoing lets stop it */
-  do_in_main_thread(FROM_HERE, base::BindOnce(schedule_direct_connect_add, app_id, addr));
+  do_in_main_thread(base::BindOnce(schedule_direct_connect_add, app_id, addr));
 }
 
 void target_announcements_filtering_set(bool enable) {
diff --git a/system/stack/include/main_thread.h b/system/stack/include/main_thread.h
index 04c93dffe7..909f95443c 100644
--- a/system/stack/include/main_thread.h
+++ b/system/stack/include/main_thread.h
@@ -17,7 +17,6 @@
 #pragma once
 
 #include <base/functional/callback.h>
-#include <base/location.h>
 #include <base/threading/thread.h>
 
 #include "common/message_loop_thread.h"
@@ -29,9 +28,8 @@ using BtMainClosure = std::function<void()>;
 bluetooth::common::MessageLoopThread* get_main_thread();
 bluetooth::common::PostableContext* get_main();
 
-bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure task);
-bt_status_t do_in_main_thread_delayed(const base::Location& from_here, base::OnceClosure task,
-                                      std::chrono::microseconds delay);
+bt_status_t do_in_main_thread(base::OnceClosure task);
+bt_status_t do_in_main_thread_delayed(base::OnceClosure task, std::chrono::microseconds delay);
 void post_on_bt_main(BtMainClosure closure);
 void main_thread_start_up();
 void main_thread_shut_down();
diff --git a/system/stack/l2cap/l2c_api.cc b/system/stack/l2cap/l2c_api.cc
index e77a398669..c7d5a57e1b 100644
--- a/system/stack/l2cap/l2c_api.cc
+++ b/system/stack/l2cap/l2c_api.cc
@@ -558,8 +558,8 @@ uint16_t L2CA_ConnectLECocReq(uint16_t psm, const RawAddress& p_bd_addr, tL2CAP_
       log::verbose("LE Link is up");
       // post this asynchronously to avoid out-of-order callback invocation
       // should this operation fail
-      do_in_main_thread(FROM_HERE, base::BindOnce(&l2c_csm_execute, base::Unretained(p_ccb),
-                                                  L2CEVT_L2CA_CONNECT_REQ, nullptr));
+      do_in_main_thread(base::BindOnce(&l2c_csm_execute, base::Unretained(p_ccb),
+                                       L2CEVT_L2CA_CONNECT_REQ, nullptr));
     }
   }
 
diff --git a/system/test/common/main_handler.cc b/system/test/common/main_handler.cc
index 3a9b6a1481..0849ef37db 100644
--- a/system/test/common/main_handler.cc
+++ b/system/test/common/main_handler.cc
@@ -39,24 +39,22 @@ void do_post_on_bt_main(BtMainClosure closure) { closure(); }
 
 }  // namespace
 
-bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure task) {
-  bluetooth::log::assert_that(main_thread.DoInThread(from_here, std::move(task)),
+bt_status_t do_in_main_thread(base::OnceClosure task) {
+  bluetooth::log::assert_that(main_thread.DoInThread(FROM_HERE, std::move(task)),
                               "Unable to run on main thread");
   return BT_STATUS_SUCCESS;
 }
 
-bt_status_t do_in_main_thread_delayed(const base::Location& from_here, base::OnceClosure task,
-                                      std::chrono::microseconds delay) {
-  bluetooth::log::assert_that(!main_thread.DoInThreadDelayed(from_here, std::move(task), delay),
+bt_status_t do_in_main_thread_delayed(base::OnceClosure task, std::chrono::microseconds delay) {
+  bluetooth::log::assert_that(!main_thread.DoInThreadDelayed(FROM_HERE, std::move(task), delay),
                               "Unable to run on main thread delayed");
   return BT_STATUS_SUCCESS;
 }
 
 void post_on_bt_main(BtMainClosure closure) {
-  bluetooth::log::assert_that(
-          do_in_main_thread(FROM_HERE, base::BindOnce(do_post_on_bt_main, std::move(closure))) ==
-                  BT_STATUS_SUCCESS,
-          "Unable to post on main thread");
+  bluetooth::log::assert_that(do_in_main_thread(base::BindOnce(
+                                      do_post_on_bt_main, std::move(closure))) == BT_STATUS_SUCCESS,
+                              "Unable to post on main thread");
 }
 
 void main_thread_start_up() {
diff --git a/system/test/common/main_handler.h b/system/test/common/main_handler.h
index 1be8c1a2c3..b2b0a3baae 100644
--- a/system/test/common/main_handler.h
+++ b/system/test/common/main_handler.h
@@ -17,7 +17,6 @@
 #pragma once
 
 #include <base/functional/callback_forward.h>
-#include <base/location.h>
 
 #include <functional>
 
@@ -28,9 +27,8 @@
 using bluetooth::common::MessageLoopThread;
 using BtMainClosure = std::function<void()>;
 
-bt_status_t do_in_main_thread(const base::Location& from_here, base::OnceClosure task);
-bt_status_t do_in_main_thread_delayed(const base::Location& from_here, base::OnceClosure task,
-                                      std::chrono::microseconds delay);
+bt_status_t do_in_main_thread(base::OnceClosure task);
+bt_status_t do_in_main_thread_delayed(base::OnceClosure task, std::chrono::microseconds delay);
 void post_on_bt_main(BtMainClosure closure);
 void main_thread_start_up();
 void main_thread_shut_down();
diff --git a/system/test/headless/bt_stack_info.cc b/system/test/headless/bt_stack_info.cc
index ee75a89c1b..ad00ba5c6b 100644
--- a/system/test/headless/bt_stack_info.cc
+++ b/system/test/headless/bt_stack_info.cc
@@ -30,10 +30,8 @@ BtStackInfo::BtStackInfo() {
   {
     std::promise<pid_t> promise;
     auto future = promise.get_future();
-    do_in_main_thread(
-            FROM_HERE,
-            base::BindOnce([](std::promise<pid_t> promise) { promise.set_value(getpid()); },
-                           std::move(promise)));
+    do_in_main_thread(base::BindOnce(
+            [](std::promise<pid_t> promise) { promise.set_value(getpid()); }, std::move(promise)));
     main_pid_ = future.get();
   }