Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2fbd8ed0 authored by David Duarte's avatar David Duarte
Browse files

Remove FROM_HERE from do_in_jni_thread invocations 

In production FROM_HERE only convey the filename
and the pc and only log the pc in case of internal
libchrome failures.

It's mainly useful in debugging by enabling
ENABLE_LOCATION_SOURCE and logging the
base::Location object ourselves.

The same information can be retrieved using c++'s
[source_location](https://en.cppreference.com/w/cpp/utility/source_location)
without needing to modify every caller.

The benefit outweight the cost of needing to provide
that (correctly) in every call site.

Bug: 345074109
Test: mmm packages/modules/Bluetooth
Flag: EXEMPT mechanical refactor
Change-Id: I5ba252baa6c885f3c34bffec058517bf39539bbe
parent f423f0f6

system/btif/avrcp/avrcp_service.cc

+35 −39
Original line number Diff line number Diff line
@@ -45,10 +45,6 @@ namespace avrcp { 
AvrcpService* AvrcpService::instance_ = nullptr;

AvrcpService::ServiceInterfaceImpl* AvrcpService::service_interface_ = nullptr;



void do_in_avrcp_jni(const base::Closure& task) {

  do_in_jni_thread(FROM_HERE, task);

}



class A2dpInterfaceImpl : public A2dpInterface {

  RawAddress active_peer() override { return btif_av_source_active_peer(); }
@@ -180,7 +176,7 @@ class MediaInterfaceWrapper : public MediaInterface { 
  MediaInterfaceWrapper(MediaInterface* cb) : wrapped_(cb){};



  void SendKeyEvent(uint8_t key, KeyState state) override {

    do_in_avrcp_jni(base::Bind(&MediaInterface::SendKeyEvent,

    do_in_jni_thread(base::Bind(&MediaInterface::SendKeyEvent,

                                base::Unretained(wrapped_), key, state));

  }
@@ -191,7 +187,7 @@ class MediaInterfaceWrapper : public MediaInterface { 


    auto bound_cb = base::Bind(cb_lambda, info_cb);



    do_in_avrcp_jni(base::Bind(&MediaInterface::GetSongInfo,

    do_in_jni_thread(base::Bind(&MediaInterface::GetSongInfo,

                                base::Unretained(wrapped_), bound_cb));

  }
@@ -202,7 +198,7 @@ class MediaInterfaceWrapper : public MediaInterface { 


    auto bound_cb = base::Bind(cb_lambda, status_cb);



    do_in_avrcp_jni(base::Bind(&MediaInterface::GetPlayStatus,

    do_in_jni_thread(base::Bind(&MediaInterface::GetPlayStatus,

                                base::Unretained(wrapped_), bound_cb));

  }
@@ -215,7 +211,7 @@ class MediaInterfaceWrapper : public MediaInterface { 


    auto bound_cb = base::Bind(cb_lambda, now_playing_cb);



    do_in_avrcp_jni(base::Bind(&MediaInterface::GetNowPlayingList,

    do_in_jni_thread(base::Bind(&MediaInterface::GetNowPlayingList,

                                base::Unretained(wrapped_), bound_cb));

  }
@@ -228,7 +224,7 @@ class MediaInterfaceWrapper : public MediaInterface { 


    auto bound_cb = base::Bind(cb_lambda, list_cb);



    do_in_avrcp_jni(base::Bind(&MediaInterface::GetMediaPlayerList,

    do_in_jni_thread(base::Bind(&MediaInterface::GetMediaPlayerList,

                                base::Unretained(wrapped_), bound_cb));

  }
@@ -241,7 +237,7 @@ class MediaInterfaceWrapper : public MediaInterface { 


    auto bound_cb = base::Bind(cb_lambda, folder_cb);



    do_in_avrcp_jni(base::Bind(&MediaInterface::GetFolderItems,

    do_in_jni_thread(base::Bind(&MediaInterface::GetFolderItems,

                                base::Unretained(wrapped_), player_id, media_id,

                                bound_cb));

  }
@@ -256,20 +252,20 @@ class MediaInterfaceWrapper : public MediaInterface { 


    auto bound_cb = base::Bind(cb_lambda, browse_cb);



    do_in_avrcp_jni(base::Bind(&MediaInterface::SetBrowsedPlayer,

    do_in_jni_thread(base::Bind(&MediaInterface::SetBrowsedPlayer,

                                base::Unretained(wrapped_), player_id,

                                bound_cb));

  }



  void PlayItem(uint16_t player_id, bool now_playing,

                std::string media_id) override {

    do_in_avrcp_jni(base::Bind(&MediaInterface::PlayItem,

    do_in_jni_thread(base::Bind(&MediaInterface::PlayItem,

                                base::Unretained(wrapped_), player_id,

                                now_playing, media_id));

  }



  void SetActiveDevice(const RawAddress& address) override {

    do_in_avrcp_jni(base::Bind(&MediaInterface::SetActiveDevice,

    do_in_jni_thread(base::Bind(&MediaInterface::SetActiveDevice,

                                base::Unretained(wrapped_), address));

  }
@@ -292,7 +288,7 @@ class VolumeInterfaceWrapper : public VolumeInterface { 
  VolumeInterfaceWrapper(VolumeInterface* interface) : wrapped_(interface){};



  void DeviceConnected(const RawAddress& bdaddr) override {

    do_in_avrcp_jni(

    do_in_jni_thread(

        base::Bind(static_cast<void (VolumeInterface::*)(const RawAddress&)>(

                       &VolumeInterface::DeviceConnected),

                   base::Unretained(wrapped_), bdaddr));
@@ -305,19 +301,19 @@ class VolumeInterfaceWrapper : public VolumeInterface { 


    auto bound_cb = base::Bind(cb_lambda, cb);



    do_in_avrcp_jni(base::Bind(static_cast<void (VolumeInterface::*)(

    do_in_jni_thread(base::Bind(static_cast<void (VolumeInterface::*)(

                                    const RawAddress&, VolumeChangedCb)>(

                                    &VolumeInterface::DeviceConnected),

                                base::Unretained(wrapped_), bdaddr, bound_cb));

  }



  void DeviceDisconnected(const RawAddress& bdaddr) override {

    do_in_avrcp_jni(base::Bind(&VolumeInterface::DeviceDisconnected,

    do_in_jni_thread(base::Bind(&VolumeInterface::DeviceDisconnected,

                                base::Unretained(wrapped_), bdaddr));

  }



  void SetVolume(int8_t volume) override {

    do_in_avrcp_jni(base::Bind(&VolumeInterface::SetVolume,

    do_in_jni_thread(base::Bind(&VolumeInterface::SetVolume,

                                base::Unretained(wrapped_), volume));

  }
@@ -340,7 +336,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface { 


    auto bound_cb = base::Bind(cb_lambda, cb);



    do_in_avrcp_jni(base::Bind(&PlayerSettingsInterface::ListPlayerSettings,

    do_in_jni_thread(base::Bind(&PlayerSettingsInterface::ListPlayerSettings,

                                base::Unretained(wrapped_), bound_cb));

  }
@@ -354,7 +350,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface { 


    auto bound_cb = base::Bind(cb_lambda, cb);



    do_in_avrcp_jni(

    do_in_jni_thread(

        base::Bind(&PlayerSettingsInterface::ListPlayerSettingValues,

                   base::Unretained(wrapped_), setting, bound_cb));

  }
@@ -371,7 +367,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface { 


    auto bound_cb = base::Bind(cb_lambda, cb);



    do_in_avrcp_jni(base::Bind(

    do_in_jni_thread(base::Bind(

        &PlayerSettingsInterface::GetCurrentPlayerSettingValue,

        base::Unretained(wrapped_), std::move(attributes), bound_cb));

  }
@@ -385,7 +381,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface { 


    auto bound_cb = base::Bind(cb_lambda, cb);



    do_in_avrcp_jni(base::Bind(

    do_in_jni_thread(base::Bind(

        &PlayerSettingsInterface::SetPlayerSettings, base::Unretained(wrapped_),

        std::move(attributes), std::move(values), bound_cb));

  }

system/btif/include/btif_common.h

+4 −9
Original line number Diff line number Diff line
@@ -99,8 +99,6 @@ typedef struct { 
 ******************************************************************************/



bt_status_t do_in_jni_thread(base::OnceClosure task);

bt_status_t do_in_jni_thread(const base::Location& from_here,

                             base::OnceClosure task);

bool is_on_jni_thread();



using BtJniClosure = std::function<void()>;
@@ -111,15 +109,12 @@ void post_on_bt_jni(BtJniClosure closure); 
 * thread

 */

template <typename R, typename... Args>

base::Callback<R(Args...)> jni_thread_wrapper(const base::Location& from_here,

                                              base::Callback<R(Args...)> cb) {

base::Callback<R(Args...)> jni_thread_wrapper(base::Callback<R(Args...)> cb) {

  return base::Bind(

      [](const base::Location& from_here, base::Callback<R(Args...)> cb,

         Args... args) {

        do_in_jni_thread(from_here,

                         base::BindOnce(cb, std::forward<Args>(args)...));

      [](base::Callback<R(Args...)> cb, Args... args) {

        do_in_jni_thread(base::BindOnce(cb, std::forward<Args>(args)...));

      },

      from_here, std::move(cb));

      std::move(cb));

}



tBTA_SERVICE_MASK btif_get_enabled_services_mask(void);

system/btif/include/btif_jni_task.h

+0 −3
Original line number Diff line number Diff line
@@ -48,9 +48,6 @@ bt_status_t btif_transfer_context(tBTIF_CBACK* p_cback, uint16_t event, 
 * This function posts a task into the btif message loop, that executes it in

 * the JNI message loop.

 **/

bt_status_t do_in_jni_thread(const base::Location& from_here,

                             base::OnceClosure task);



bt_status_t do_in_jni_thread(base::OnceClosure task);



bool is_on_jni_thread();

system/btif/src/bluetooth.cc

+130 −163
Original line number Diff line number Diff line
@@ -741,9 +741,7 @@ static int disconnect_all_acls() { 


static void le_rand_btif_cb(uint64_t random_number) {

  log::verbose("");

  do_in_jni_thread(

      FROM_HERE,

      base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](uint64_t random) { HAL_CBACK(bt_hal_cbacks, le_rand_cb, random); },

      random_number));

}
@@ -987,17 +985,13 @@ int le_test_mode(uint16_t opcode, uint8_t* buf, uint8_t len) { 
static bt_os_callouts_t* wakelock_os_callouts_saved = nullptr;



static int acquire_wake_lock_cb(const char* lock_name) {

  return do_in_jni_thread(

      FROM_HERE,

      base::BindOnce(

  return do_in_jni_thread(base::BindOnce(

      base::IgnoreResult(wakelock_os_callouts_saved->acquire_wake_lock),

      lock_name));

}



static int release_wake_lock_cb(const char* lock_name) {

  return do_in_jni_thread(

      FROM_HERE,

      base::BindOnce(

  return do_in_jni_thread(base::BindOnce(

      base::IgnoreResult(wakelock_os_callouts_saved->release_wake_lock),

      lock_name));

}
@@ -1263,22 +1257,19 @@ bt_property_t* property_deep_copy_array(int num_properties, 
}



void invoke_adapter_state_changed_cb(bt_state_t state) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bt_state_t state) {

                                    HAL_CBACK(bt_hal_cbacks,

                                              adapter_state_changed_cb, state);

        HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, state);

      },

      state));

}



void invoke_adapter_properties_cb(bt_status_t status, int num_properties,

                                  bt_property_t* properties) {

  do_in_jni_thread(FROM_HERE,

                   base::BindOnce(

                       [](bt_status_t status, int num_properties,

                          bt_property_t* properties) {

                         HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status,

                                   num_properties, properties);

  do_in_jni_thread(base::BindOnce(

      [](bt_status_t status, int num_properties, bt_property_t* properties) {

        HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, num_properties,

                  properties);

        if (properties) {

          osi_free(properties);

        }
@@ -1290,12 +1281,11 @@ void invoke_adapter_properties_cb(bt_status_t status, int num_properties, 
void invoke_remote_device_properties_cb(bt_status_t status, RawAddress bd_addr,

                                        int num_properties,

                                        bt_property_t* properties) {

  do_in_jni_thread(

      FROM_HERE, base::BindOnce(

                     [](bt_status_t status, RawAddress bd_addr,

                        int num_properties, bt_property_t* properties) {

                       HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,

                                 status, &bd_addr, num_properties, properties);

  do_in_jni_thread(base::BindOnce(

      [](bt_status_t status, RawAddress bd_addr, int num_properties,

         bt_property_t* properties) {

        HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, status, &bd_addr,

                  num_properties, properties);

        if (properties) {

          osi_free(properties);

        }
@@ -1305,36 +1295,30 @@ void invoke_remote_device_properties_cb(bt_status_t status, RawAddress bd_addr, 
}



void invoke_device_found_cb(int num_properties, bt_property_t* properties) {

  do_in_jni_thread(FROM_HERE,

                   base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](int num_properties, bt_property_t* properties) {

                         HAL_CBACK(bt_hal_cbacks, device_found_cb,

                                   num_properties, properties);

        HAL_CBACK(bt_hal_cbacks, device_found_cb, num_properties, properties);

        if (properties) {

          osi_free(properties);

        }

      },

                       num_properties,

                       property_deep_copy_array(num_properties, properties)));

      num_properties, property_deep_copy_array(num_properties, properties)));

}



void invoke_discovery_state_changed_cb(bt_discovery_state_t state) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bt_discovery_state_t state) {

                                    HAL_CBACK(bt_hal_cbacks,

                                              discovery_state_changed_cb,

                                              state);

        HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb, state);

      },

      state));

}



void invoke_pin_request_cb(RawAddress bd_addr, bt_bdname_t bd_name,

                           uint32_t cod, bool min_16_digit) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

                                  [](RawAddress bd_addr, bt_bdname_t bd_name,

                                     uint32_t cod, bool min_16_digit) {

                                    HAL_CBACK(bt_hal_cbacks, pin_request_cb,

                                              &bd_addr, &bd_name, cod,

  do_in_jni_thread(base::BindOnce(

      [](RawAddress bd_addr, bt_bdname_t bd_name, uint32_t cod,

         bool min_16_digit) {

        HAL_CBACK(bt_hal_cbacks, pin_request_cb, &bd_addr, &bd_name, cod,

                  min_16_digit);

      },

      bd_addr, bd_name, cod, min_16_digit));
@@ -1342,12 +1326,11 @@ void invoke_pin_request_cb(RawAddress bd_addr, bt_bdname_t bd_name, 


void invoke_ssp_request_cb(RawAddress bd_addr, bt_ssp_variant_t pairing_variant,

                           uint32_t pass_key) {

  do_in_jni_thread(FROM_HERE,

                   base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](RawAddress bd_addr, bt_ssp_variant_t pairing_variant,

         uint32_t pass_key) {

                         HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr,

                                   pairing_variant, pass_key);

        HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, pairing_variant,

                  pass_key);

      },

      bd_addr, pairing_variant, pass_key));

}
@@ -1388,11 +1371,9 @@ void invoke_oob_data_request_cb(tBT_TRANSPORT t, bool valid, Octet16 c, 
  // of itself. 16 + 16 + 2 = 34 Data 0x0022 Little Endian order 0x2200

  oob_data.oob_data_length[0] = 0;

  oob_data.oob_data_length[1] = 34;

  bt_status_t status = do_in_jni_thread(

      FROM_HERE, base::BindOnce(

  bt_status_t status = do_in_jni_thread(base::BindOnce(

      [](tBT_TRANSPORT t, bt_oob_data_t oob_data) {

                       HAL_CBACK(bt_hal_cbacks, generate_local_oob_data_cb, t,

                                 oob_data);

        HAL_CBACK(bt_hal_cbacks, generate_local_oob_data_cb, t, oob_data);

      },

      t, oob_data));

  if (status != BT_STATUS_SUCCESS) {
@@ -1402,34 +1383,31 @@ void invoke_oob_data_request_cb(tBT_TRANSPORT t, bool valid, Octet16 c, 


void invoke_bond_state_changed_cb(bt_status_t status, RawAddress bd_addr,

                                  bt_bond_state_t state, int fail_reason) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

                                  [](bt_status_t status, RawAddress bd_addr,

                                     bt_bond_state_t state, int fail_reason) {

                                    HAL_CBACK(bt_hal_cbacks,

                                              bond_state_changed_cb, status,

                                              &bd_addr, state, fail_reason);

  do_in_jni_thread(base::BindOnce(

      [](bt_status_t status, RawAddress bd_addr, bt_bond_state_t state,

         int fail_reason) {

        HAL_CBACK(bt_hal_cbacks, bond_state_changed_cb, status, &bd_addr, state,

                  fail_reason);

      },

      status, bd_addr, state, fail_reason));

}



void invoke_address_consolidate_cb(RawAddress main_bd_addr,

                                   RawAddress secondary_bd_addr) {

  do_in_jni_thread(

      FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](RawAddress main_bd_addr, RawAddress secondary_bd_addr) {

                       HAL_CBACK(bt_hal_cbacks, address_consolidate_cb,

                                 &main_bd_addr, &secondary_bd_addr);

        HAL_CBACK(bt_hal_cbacks, address_consolidate_cb, &main_bd_addr,

                  &secondary_bd_addr);

      },

      main_bd_addr, secondary_bd_addr));

}



void invoke_le_address_associate_cb(RawAddress main_bd_addr,

                                    RawAddress secondary_bd_addr) {

  do_in_jni_thread(

      FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](RawAddress main_bd_addr, RawAddress secondary_bd_addr) {

                       HAL_CBACK(bt_hal_cbacks, le_address_associate_cb,

                                 &main_bd_addr, &secondary_bd_addr);

        HAL_CBACK(bt_hal_cbacks, le_address_associate_cb, &main_bd_addr,

                  &secondary_bd_addr);

      },

      main_bd_addr, secondary_bd_addr));

}
@@ -1438,25 +1416,21 @@ void invoke_acl_state_changed_cb(bt_status_t status, RawAddress bd_addr, 
                                 bt_hci_error_code_t hci_reason,

                                 bt_conn_direction_t direction,

                                 uint16_t acl_handle) {

  do_in_jni_thread(

      FROM_HERE,

      base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bt_status_t status, RawAddress bd_addr, bt_acl_state_t state,

         int transport_link_type, bt_hci_error_code_t hci_reason,

         bt_conn_direction_t direction, uint16_t acl_handle) {

            HAL_CBACK(bt_hal_cbacks, acl_state_changed_cb, status, &bd_addr,

                      state, transport_link_type, hci_reason, direction,

                      acl_handle);

        HAL_CBACK(bt_hal_cbacks, acl_state_changed_cb, status, &bd_addr, state,

                  transport_link_type, hci_reason, direction, acl_handle);

      },

      status, bd_addr, state, transport_link_type, hci_reason, direction,

      acl_handle));

}



void invoke_thread_evt_cb(bt_cb_thread_evt event) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bt_cb_thread_evt event) {

                                    HAL_CBACK(bt_hal_cbacks, thread_evt_cb,

                                              event);

        HAL_CBACK(bt_hal_cbacks, thread_evt_cb, event);

        if (event == DISASSOCIATE_JVM) {

          bt_hal_cbacks = NULL;

        }
@@ -1465,10 +1439,9 @@ void invoke_thread_evt_cb(bt_cb_thread_evt event) { 
}



void invoke_le_test_mode_cb(bt_status_t status, uint16_t count) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bt_status_t status, uint16_t count) {

                                    HAL_CBACK(bt_hal_cbacks, le_test_mode_cb,

                                              status, count);

        HAL_CBACK(bt_hal_cbacks, le_test_mode_cb, status, count);

      },

      status, count));

}
@@ -1476,9 +1449,7 @@ void invoke_le_test_mode_cb(bt_status_t status, uint16_t count) { 
// takes ownership of |uid_data|

void invoke_energy_info_cb(bt_activity_energy_info energy_info,

                           bt_uid_traffic_t* uid_data) {

  do_in_jni_thread(

      FROM_HERE,

      base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bt_activity_energy_info energy_info, bt_uid_traffic_t* uid_data) {

        HAL_CBACK(bt_hal_cbacks, energy_info_cb, &energy_info, uid_data);

        osi_free(uid_data);
@@ -1491,7 +1462,6 @@ void invoke_link_quality_report_cb(uint64_t timestamp, int report_id, int rssi, 
                                   int packets_not_receive_count,

                                   int negative_acknowledgement_count) {

  do_in_jni_thread(

      FROM_HERE,

      base::BindOnce(

          [](uint64_t timestamp, int report_id, int rssi, int snr,

             int retransmission_count, int packets_not_receive_count,
@@ -1506,29 +1476,26 @@ void invoke_link_quality_report_cb(uint64_t timestamp, int report_id, int rssi, 
}



void invoke_switch_buffer_size_cb(bool is_low_latency_buffer_size) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bool is_low_latency_buffer_size) {

                                    HAL_CBACK(bt_hal_cbacks,

                                              switch_buffer_size_cb,

        HAL_CBACK(bt_hal_cbacks, switch_buffer_size_cb,

                  is_low_latency_buffer_size);

      },

      is_low_latency_buffer_size));

}



void invoke_switch_codec_cb(bool is_low_latency_buffer_size) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](bool is_low_latency_buffer_size) {

                                    HAL_CBACK(bt_hal_cbacks, switch_codec_cb,

                                              is_low_latency_buffer_size);

        HAL_CBACK(bt_hal_cbacks, switch_codec_cb, is_low_latency_buffer_size);

      },

      is_low_latency_buffer_size));

}



void invoke_key_missing_cb(RawAddress bd_addr) {

  do_in_jni_thread(FROM_HERE, base::BindOnce(

  do_in_jni_thread(base::BindOnce(

      [](RawAddress bd_addr) {

                                    HAL_CBACK(bt_hal_cbacks, key_missing_cb,

                                              bd_addr);

        HAL_CBACK(bt_hal_cbacks, key_missing_cb, bd_addr);

      },

      bd_addr));

}

system/btif/src/btif_av.cc

+16 −29
Original line number Diff line number Diff line
@@ -2942,12 +2942,10 @@ static void btif_report_connection_state(const RawAddress& peer_address, 


    if (peer->IsSink()) {

      do_in_jni_thread(

          FROM_HERE,

          base::BindOnce(btif_av_source.Callbacks()->connection_state_cb,

                         peer_address, state, btav_error_t{}));

    } else if (peer->IsSource()) {

      do_in_jni_thread(

          FROM_HERE,

          base::BindOnce(btif_av_sink.Callbacks()->connection_state_cb,

                         peer_address, state, btav_error_t{}));

    }
@@ -2955,15 +2953,11 @@ static void btif_report_connection_state(const RawAddress& peer_address, 
  }



  if (btif_av_source.Enabled()) {

    do_in_jni_thread(

        FROM_HERE,

        base::BindOnce(

            btif_av_source.Callbacks()->connection_state_cb, peer_address,

            state, btav_error_t{.status = status, .error_code = error_code}));

    do_in_jni_thread(base::BindOnce(

        btif_av_source.Callbacks()->connection_state_cb, peer_address, state,

        btav_error_t{.status = status, .error_code = error_code}));

  } else if (btif_av_sink.Enabled()) {

    do_in_jni_thread(

        FROM_HERE,

        base::BindOnce(

    do_in_jni_thread(base::BindOnce(

        btif_av_sink.Callbacks()->connection_state_cb, peer_address, state,

        btav_error_t{.status = status, .error_code = error_code}));

  }
@@ -2986,23 +2980,19 @@ static void btif_report_audio_state(const RawAddress& peer_address, 
  if (btif_av_both_enable()) {

    BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);

    if (peer->IsSink()) {

      do_in_jni_thread(

          FROM_HERE, base::BindOnce(btif_av_source.Callbacks()->audio_state_cb,

                                    peer_address, state));

      do_in_jni_thread(base::BindOnce(

          btif_av_source.Callbacks()->audio_state_cb, peer_address, state));

    } else if (peer->IsSource()) {

      do_in_jni_thread(FROM_HERE,

                       base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,

      do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,

                                      peer_address, state));

    }

    return;

  }

  if (btif_av_source.Enabled()) {

    do_in_jni_thread(FROM_HERE,

                     base::BindOnce(btif_av_source.Callbacks()->audio_state_cb,

    do_in_jni_thread(base::BindOnce(btif_av_source.Callbacks()->audio_state_cb,

                                    peer_address, state));

  } else if (btif_av_sink.Enabled()) {

    do_in_jni_thread(FROM_HERE,

                     base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,

    do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,

                                    peer_address, state));

  }
@@ -3035,11 +3025,9 @@ void btif_av_report_source_codec_state( 
        codecs_selectable_capabilities) {

  log::verbose("peer={}", peer_address);

  if (btif_av_source.Enabled()) {

    do_in_jni_thread(

        FROM_HERE,

        base::BindOnce(btif_av_source.Callbacks()->audio_config_cb,

                       peer_address, codec_config, codecs_local_capabilities,

                       codecs_selectable_capabilities));

    do_in_jni_thread(base::BindOnce(

        btif_av_source.Callbacks()->audio_config_cb, peer_address, codec_config,

        codecs_local_capabilities, codecs_selectable_capabilities));

  }

}
@@ -3055,8 +3043,7 @@ static void btif_av_report_sink_audio_config_state( 
  log::info("peer={} sample_rate={} channel_count={}", peer_address,

            sample_rate, channel_count);

  if (btif_av_sink.Enabled()) {

    do_in_jni_thread(FROM_HERE,

                     base::BindOnce(btif_av_sink.Callbacks()->audio_config_cb,

    do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_config_cb,

                                    peer_address, sample_rate, channel_count));

  }

}
@@ -3091,7 +3078,7 @@ static void btif_av_query_mandatory_codec_priority( 
    }

  };

  if (btif_av_source.Enabled()) {

    do_in_jni_thread(FROM_HERE, base::BindOnce(query_priority, peer_address));

    do_in_jni_thread(base::BindOnce(query_priority, peer_address));

  }

}