Remove usage of base::Owned in BTM_SetEncryption

Test: mmm packages/modules/Bluetooth
Bug: 345074109
Flag: EXEMPT, mechanical refactor
Change-Id: I909690e7e83a5862db20b1cd32c0020801d3d551

16 files changed, 71 insertions, 79 deletions

diff --git a/system/bta/dm/bta_dm_sec.cc b/system/bta/dm/bta_dm_sec.cc
index 2febfcce3e..de4ea73dc8 100644
--- a/system/bta/dm/bta_dm_sec.cc
+++ b/system/bta/dm/bta_dm_sec.cc
@@ -794,17 +794,17 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
  * Returns         None
  *
  ******************************************************************************/
-void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
+void bta_dm_encrypt_cback(RawAddress bd_addr, tBT_TRANSPORT transport,
                           void* /* p_ref_data */, tBTM_STATUS result) {
   tBTA_DM_ENCRYPT_CBACK* p_callback = nullptr;
-  tBTA_DM_PEER_DEVICE* device = find_connected_device(*bd_addr, transport);
+  tBTA_DM_PEER_DEVICE* device = find_connected_device(bd_addr, transport);
   if (device != nullptr) {
     p_callback = device->p_encrypt_cback;
     device->p_encrypt_cback = nullptr;
   }
 
   log::debug("Encrypted:{:c}, peer:{} transport:{} status:{} callback:{:c}",
-             result == BTM_SUCCESS ? 'T' : 'F', *bd_addr,
+             result == BTM_SUCCESS ? 'T' : 'F', bd_addr,
              bt_transport_text(transport), btm_status_text(result),
              (p_callback) ? 'T' : 'F');
 
@@ -827,7 +827,7 @@ void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
   }
 
   if (p_callback) {
-    (*p_callback)(*bd_addr, transport, bta_status);
+    (*p_callback)(bd_addr, transport, bta_status);
   }
 }
 
diff --git a/system/bta/hearing_aid/hearing_aid.cc b/system/bta/hearing_aid/hearing_aid.cc
index 7f7985ffd1..7db58aa9fe 100644
--- a/system/bta/hearing_aid/hearing_aid.cc
+++ b/system/bta/hearing_aid/hearing_aid.cc
@@ -118,8 +118,7 @@ Uuid LE_PSM_UUID               = Uuid::FromString("2d410339-82b6-42aa-b34e-e2e01
 
 static void read_rssi_callback(void* p_void);
 static void hearingaid_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data);
-static void encryption_callback(const RawAddress*, tBT_TRANSPORT, void*,
-                                tBTM_STATUS);
+static void encryption_callback(RawAddress, tBT_TRANSPORT, void*, tBTM_STATUS);
 
 inline BT_HDR* malloc_l2cap_buf(uint16_t len) {
   BT_HDR* msg = (BT_HDR*)osi_malloc(BT_HDR_SIZE + L2CAP_MIN_OFFSET +
@@ -2156,10 +2155,10 @@ static void hearingaid_gattc_callback(tBTA_GATTC_EVT event,
   }
 }
 
-static void encryption_callback(const RawAddress* address, tBT_TRANSPORT, void*,
+static void encryption_callback(RawAddress address, tBT_TRANSPORT, void*,
                                 tBTM_STATUS status) {
   if (instance) {
-    instance->OnEncryptionComplete(*address,
+    instance->OnEncryptionComplete(address,
                                    status == BTM_SUCCESS ? true : false);
   }
 }
diff --git a/system/bta/hh/bta_hh_le.cc b/system/bta/hh/bta_hh_le.cc
index 4ac2f843ea..b60754ebea 100644
--- a/system/bta/hh/bta_hh_le.cc
+++ b/system/bta/hh/bta_hh_le.cc
@@ -971,12 +971,11 @@ static void bta_hh_le_pri_service_discovery(tBTA_HH_DEV_CB* p_cb) {
  * Returns          None
  *
  ******************************************************************************/
-static void bta_hh_le_encrypt_cback(const RawAddress* bd_addr,
-                                    tBT_TRANSPORT transport,
+static void bta_hh_le_encrypt_cback(RawAddress bd_addr, tBT_TRANSPORT transport,
                                     void* /* p_ref_data */,
                                     tBTM_STATUS result) {
   tAclLinkSpec link_spec;
-  link_spec.addrt.bda = *bd_addr;
+  link_spec.addrt.bda = bd_addr;
   link_spec.addrt.type = BLE_ADDR_PUBLIC;
   link_spec.transport = transport;
 
diff --git a/system/bta/test/bta_dm_test.cc b/system/bta/test/bta_dm_test.cc
index 2bbc94b969..289afdf36d 100644
--- a/system/bta/test/bta_dm_test.cc
+++ b/system/bta/test/bta_dm_test.cc
@@ -266,7 +266,7 @@ TEST_F(BtaDmTest, bta_dm_set_encryption) {
   BTA_DM_ENCRYPT_CBACK_queue = {};
 }
 
-void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
+void bta_dm_encrypt_cback(RawAddress bd_addr, tBT_TRANSPORT transport,
                           void* /* p_ref_data */, tBTM_STATUS result);
 
 TEST_F(BtaDmTest, bta_dm_encrypt_cback) {
@@ -280,20 +280,20 @@ TEST_F(BtaDmTest, bta_dm_encrypt_cback) {
 
   // Encryption with no callback set
   device->p_encrypt_cback = nullptr;
-  bta_dm_encrypt_cback(&kRawAddress, transport, nullptr, BTM_SUCCESS);
+  bta_dm_encrypt_cback(kRawAddress, transport, nullptr, BTM_SUCCESS);
   ASSERT_EQ(0UL, BTA_DM_ENCRYPT_CBACK_queue.size());
 
   // Encryption with callback
   device->p_encrypt_cback = BTA_DM_ENCRYPT_CBACK;
-  bta_dm_encrypt_cback(&kRawAddress, transport, nullptr, BTM_SUCCESS);
+  bta_dm_encrypt_cback(kRawAddress, transport, nullptr, BTM_SUCCESS);
   device->p_encrypt_cback = BTA_DM_ENCRYPT_CBACK;
-  bta_dm_encrypt_cback(&kRawAddress, transport, nullptr, BTM_WRONG_MODE);
+  bta_dm_encrypt_cback(kRawAddress, transport, nullptr, BTM_WRONG_MODE);
   device->p_encrypt_cback = BTA_DM_ENCRYPT_CBACK;
-  bta_dm_encrypt_cback(&kRawAddress, transport, nullptr, BTM_NO_RESOURCES);
+  bta_dm_encrypt_cback(kRawAddress, transport, nullptr, BTM_NO_RESOURCES);
   device->p_encrypt_cback = BTA_DM_ENCRYPT_CBACK;
-  bta_dm_encrypt_cback(&kRawAddress, transport, nullptr, BTM_BUSY);
+  bta_dm_encrypt_cback(kRawAddress, transport, nullptr, BTM_BUSY);
   device->p_encrypt_cback = BTA_DM_ENCRYPT_CBACK;
-  bta_dm_encrypt_cback(&kRawAddress, transport, nullptr, BTM_ILLEGAL_VALUE);
+  bta_dm_encrypt_cback(kRawAddress, transport, nullptr, BTM_ILLEGAL_VALUE);
 
   ASSERT_EQ(5UL, BTA_DM_ENCRYPT_CBACK_queue.size());
 
diff --git a/system/bta/vc/vc_test.cc b/system/bta/vc/vc_test.cc
index 5af10ddb38..1d3b4beb15 100644
--- a/system/bta/vc/vc_test.cc
+++ b/system/bta/vc/vc_test.cc
@@ -475,7 +475,7 @@ class VolumeControlTest : public ::testing::Test {
                              tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
                              tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {
               if (p_callback) {
-                p_callback(&bd_addr, transport, p_ref_data,
+                p_callback(bd_addr, transport, p_ref_data,
                            success ? BTM_SUCCESS : BTM_FAILED_ON_SECURITY);
               }
               GetEncryptionCompleteEvt(bd_addr);
diff --git a/system/stack/btm/btm_ble_sec.cc b/system/stack/btm/btm_ble_sec.cc
index 6ac9fbc597..7f647cabb0 100644
--- a/system/stack/btm/btm_ble_sec.cc
+++ b/system/stack/btm/btm_ble_sec.cc
@@ -728,7 +728,7 @@ tBTM_STATUS btm_ble_start_sec_check(const RawAddress& bd_addr, uint16_t psm,
    */
   if (!p_serv_rec) {
     log::warn("PSM: {} no application registered", psm);
-    (*p_callback)(&bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_MODE_UNSUPPORTED);
+    (*p_callback)(bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_MODE_UNSUPPORTED);
     return BTM_ILLEGAL_VALUE;
   }
 
@@ -759,7 +759,7 @@ tBTM_STATUS btm_ble_start_sec_check(const RawAddress& bd_addr, uint16_t psm,
   switch (sec_act) {
     case BTM_SEC_OK:
       log::debug("Security met");
-      p_callback(&bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_SUCCESS);
+      p_callback(bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_SUCCESS);
       break;
 
     case BTM_SEC_ENCRYPT:
diff --git a/system/stack/btm/btm_sec.cc b/system/stack/btm/btm_sec.cc
index c2184762de..77de571edc 100644
--- a/system/stack/btm/btm_sec.cc
+++ b/system/stack/btm/btm_sec.cc
@@ -925,8 +925,6 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
     return BTM_WRONG_MODE;
   }
 
-  auto owned_bd_addr = base::Owned(new RawAddress(bd_addr));
-
   switch (transport) {
     case BT_TRANSPORT_BR_EDR:
       if (p_dev_rec->hci_handle == HCI_INVALID_HANDLE) {
@@ -935,9 +933,9 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
             "transport:{}",
             bd_addr, bt_transport_text(transport));
         if (p_callback) {
-          do_in_main_thread(
-              FROM_HERE, base::BindOnce(p_callback, std::move(owned_bd_addr),
-                                        transport, p_ref_data, BTM_WRONG_MODE));
+          do_in_main_thread(FROM_HERE,
+                            base::BindOnce(p_callback, bd_addr, transport,
+                                           p_ref_data, BTM_WRONG_MODE));
         }
         return BTM_WRONG_MODE;
       }
@@ -948,8 +946,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
             bd_addr, bt_transport_text(transport));
         if (p_callback) {
           do_in_main_thread(FROM_HERE,
-                            base::BindOnce(p_callback, std::move(owned_bd_addr),
-                                           transport, p_ref_data, BTM_SUCCESS));
+                            base::BindOnce(p_callback, bd_addr, transport,
+                                           p_ref_data, BTM_SUCCESS));
         }
         return BTM_SUCCESS;
       }
@@ -962,9 +960,9 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
             "transport:{}",
             bd_addr, bt_transport_text(transport));
         if (p_callback) {
-          do_in_main_thread(
-              FROM_HERE, base::BindOnce(p_callback, std::move(owned_bd_addr),
-                                        transport, p_ref_data, BTM_WRONG_MODE));
+          do_in_main_thread(FROM_HERE,
+                            base::BindOnce(p_callback, bd_addr, transport,
+                                           p_ref_data, BTM_WRONG_MODE));
         }
         return BTM_WRONG_MODE;
       }
@@ -975,8 +973,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
             bd_addr, bt_transport_text(transport));
         if (p_callback) {
           do_in_main_thread(FROM_HERE,
-                            base::BindOnce(p_callback, std::move(owned_bd_addr),
-                                           transport, p_ref_data, BTM_SUCCESS));
+                            base::BindOnce(p_callback, bd_addr, transport,
+                                           p_ref_data, BTM_SUCCESS));
         }
         return BTM_SUCCESS;
       }
@@ -1081,10 +1079,9 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
         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, std::move(owned_bd_addr), transport,
-                           p_dev_rec->sec_rec.p_ref_data, rc));
+        do_in_main_thread(FROM_HERE,
+                          base::BindOnce(p_callback, bd_addr, transport,
+                                         p_dev_rec->sec_rec.p_ref_data, rc));
       }
       break;
   }
@@ -1483,7 +1480,7 @@ tBTM_STATUS btm_sec_l2cap_access_req_by_requirement(
           "rmt_support_for_sc={}, failing connection",
           local_supports_sc, p_dev_rec->SupportsSecureConnections());
       if (p_callback) {
-        (*p_callback)(&bd_addr, transport, (void*)p_ref_data,
+        (*p_callback)(bd_addr, transport, (void*)p_ref_data,
                       BTM_MODE4_LEVEL4_NOT_SUPPORTED);
       }
 
@@ -1547,7 +1544,7 @@ tBTM_STATUS btm_sec_l2cap_access_req_by_requirement(
         }
 
         if (p_callback)
-          (*p_callback)(&bd_addr, transport, (void*)p_ref_data, rc);
+          (*p_callback)(bd_addr, transport, (void*)p_ref_data, rc);
         return rc;
       }
     }
@@ -1614,7 +1611,7 @@ tBTM_STATUS btm_sec_l2cap_access_req_by_requirement(
           "peer should have initiated security process by now (SM4 to SM4)");
       p_dev_rec->sec_rec.p_callback = p_callback;
       p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_DELAY_FOR_ENC;
-      (*p_callback)(&bd_addr, transport, p_ref_data, rc);
+      (*p_callback)(bd_addr, transport, p_ref_data, rc);
 
       return BTM_SUCCESS;
     }
@@ -1646,7 +1643,7 @@ tBTM_STATUS btm_sec_l2cap_access_req_by_requirement(
     log::verbose("p_dev_rec={}, clearing callback. old p_callback={}",
                  fmt::ptr(p_dev_rec), fmt::ptr(p_dev_rec->sec_rec.p_callback));
     p_dev_rec->sec_rec.p_callback = NULL;
-    (*p_callback)(&bd_addr, transport, p_dev_rec->sec_rec.p_ref_data, rc);
+    (*p_callback)(bd_addr, transport, p_dev_rec->sec_rec.p_ref_data, rc);
   }
 
   return (rc);
@@ -1686,14 +1683,14 @@ tBTM_STATUS btm_sec_l2cap_access_req(const RawAddress& bd_addr, uint16_t psm,
   // If there is no application registered with this PSM do not allow connection
   if (!p_serv_rec) {
     log::warn("PSM: 0x{:04x} no application registered", psm);
-    (*p_callback)(&bd_addr, transport, p_ref_data, BTM_MODE_UNSUPPORTED);
+    (*p_callback)(bd_addr, transport, p_ref_data, BTM_MODE_UNSUPPORTED);
     return (BTM_MODE_UNSUPPORTED);
   }
 
   /* Services level0 by default have no security */
   if (psm == BT_PSM_SDP) {
     log::debug("No security required for SDP");
-    (*p_callback)(&bd_addr, transport, p_ref_data, BTM_SUCCESS_NO_SECURITY);
+    (*p_callback)(bd_addr, transport, p_ref_data, BTM_SUCCESS_NO_SECURITY);
     return (BTM_SUCCESS);
   }
 
@@ -1814,7 +1811,7 @@ tBTM_STATUS btm_sec_mx_access_request(const RawAddress& bd_addr,
       }
       if (p_callback) {
         log::debug("Notifying client that security access has been granted");
-        (*p_callback)(&bd_addr, transport, p_ref_data, rc);
+        (*p_callback)(bd_addr, transport, p_ref_data, rc);
       }
     }
     return rc;
@@ -1832,7 +1829,7 @@ tBTM_STATUS btm_sec_mx_access_request(const RawAddress& bd_addr,
           "remote_SC_support:{}",
           local_supports_sc, p_dev_rec->SupportsSecureConnections());
       if (p_callback)
-        (*p_callback)(&bd_addr, transport, (void*)p_ref_data,
+        (*p_callback)(bd_addr, transport, (void*)p_ref_data,
                       BTM_MODE4_LEVEL4_NOT_SUPPORTED);
 
       return (BTM_MODE4_LEVEL4_NOT_SUPPORTED);
@@ -1881,7 +1878,7 @@ tBTM_STATUS btm_sec_mx_access_request(const RawAddress& bd_addr,
   if (rc != BTM_CMD_STARTED) {
     if (p_callback) {
       p_dev_rec->sec_rec.p_callback = NULL;
-      (*p_callback)(&bd_addr, transport, p_ref_data, rc);
+      (*p_callback)(bd_addr, transport, p_ref_data, rc);
     }
   }
 
@@ -3931,7 +3928,7 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason,
     /* when the peer device time out the authentication before
        we do, this call back must be reset here */
     p_dev_rec->sec_rec.p_callback = nullptr;
-    (*p_callback)(&p_dev_rec->bd_addr, transport, p_dev_rec->sec_rec.p_ref_data,
+    (*p_callback)(p_dev_rec->bd_addr, transport, p_dev_rec->sec_rec.p_ref_data,
                   BTM_ERR_PROCESSING);
     log::debug("Cleaned up pending security state device:{} transport:{}",
                p_dev_rec->bd_addr, bt_transport_text(transport));
@@ -4641,7 +4638,7 @@ static void btm_sec_auth_timer_timeout(void* data) {
   } else if (btm_dev_authenticated(p_dev_rec)) {
     log::info("device is already authenticated");
     if (p_dev_rec->sec_rec.p_callback) {
-      (*p_dev_rec->sec_rec.p_callback)(&p_dev_rec->bd_addr, BT_TRANSPORT_BR_EDR,
+      (*p_dev_rec->sec_rec.p_callback)(p_dev_rec->bd_addr, BT_TRANSPORT_BR_EDR,
                                        p_dev_rec->sec_rec.p_ref_data,
                                        BTM_SUCCESS);
     }
@@ -4819,10 +4816,10 @@ void btm_sec_dev_rec_cback_event(tBTM_SEC_DEV_REC* p_dev_rec,
   p_dev_rec->sec_rec.p_callback = NULL;
   if (p_callback != nullptr) {
     if (is_le_transport) {
-      (*p_callback)(&p_dev_rec->ble.pseudo_addr, BT_TRANSPORT_LE,
+      (*p_callback)(p_dev_rec->ble.pseudo_addr, BT_TRANSPORT_LE,
                     p_dev_rec->sec_rec.p_ref_data, btm_status);
     } else {
-      (*p_callback)(&p_dev_rec->bd_addr, BT_TRANSPORT_BR_EDR,
+      (*p_callback)(p_dev_rec->bd_addr, BT_TRANSPORT_BR_EDR,
                     p_dev_rec->sec_rec.p_ref_data, btm_status);
     }
   }
@@ -4968,7 +4965,7 @@ static void btm_sec_check_pending_enc_req(tBTM_SEC_DEV_REC* p_dev_rec,
           (p_e->sec_act == BTM_BLE_SEC_ENCRYPT_MITM &&
            p_dev_rec->sec_rec.sec_flags & BTM_SEC_LE_AUTHENTICATED)) {
         if (p_e->p_callback)
-          (*p_e->p_callback)(&p_dev_rec->bd_addr, transport, p_e->p_ref_data,
+          (*p_e->p_callback)(p_dev_rec->bd_addr, transport, p_e->p_ref_data,
                              res);
         fixed_queue_try_remove_from_queue(btm_sec_cb.sec_pending_q, (void*)p_e);
         osi_free(p_e);
diff --git a/system/stack/gatt/gatt_auth.cc b/system/stack/gatt/gatt_auth.cc
index f0c8029418..c2e003a64b 100644
--- a/system/stack/gatt/gatt_auth.cc
+++ b/system/stack/gatt/gatt_auth.cc
@@ -155,11 +155,10 @@ static void gatt_sec_check_complete(bool sec_check_ok, tGATT_CLCB* p_clcb,
  * Returns
  *
  ******************************************************************************/
-static void gatt_enc_cmpl_cback(const RawAddress* bd_addr,
-                                tBT_TRANSPORT transport, void* /* p_ref_data */,
-                                tBTM_STATUS result) {
+static void gatt_enc_cmpl_cback(RawAddress bd_addr, tBT_TRANSPORT transport,
+                                void* /* p_ref_data */, tBTM_STATUS result) {
   log::verbose("");
-  tGATT_TCB* p_tcb = gatt_find_tcb_by_addr(*bd_addr, transport);
+  tGATT_TCB* p_tcb = gatt_find_tcb_by_addr(bd_addr, transport);
   if (!p_tcb) {
     log::error("enc callback for unknown bd_addr");
     return;
@@ -179,7 +178,7 @@ static void gatt_enc_cmpl_cback(const RawAddress* bd_addr,
     bool status = false;
     if (result == BTM_SUCCESS) {
       if (gatt_get_sec_act(p_tcb) == GATT_SEC_ENCRYPT_MITM) {
-        status = BTM_IsLinkKeyAuthed(*bd_addr, transport);
+        status = BTM_IsLinkKeyAuthed(bd_addr, transport);
       } else {
         status = true;
       }
diff --git a/system/stack/include/btm_sec_api_types.h b/system/stack/include/btm_sec_api_types.h
index 02c4d40c95..1a52d46591 100644
--- a/system/stack/include/btm_sec_api_types.h
+++ b/system/stack/include/btm_sec_api_types.h
@@ -378,9 +378,8 @@ typedef void(tBTM_MKEY_CALLBACK)(const RawAddress& bd_addr, uint8_t status,
  *              optional data passed in by BTM_SetEncryption
  *              tBTM_STATUS - result of the operation
 */
-typedef void(tBTM_SEC_CALLBACK)(const RawAddress* bd_addr,
-                                tBT_TRANSPORT trasnport, void* p_ref_data,
-                                tBTM_STATUS result);
+typedef void(tBTM_SEC_CALLBACK)(RawAddress bd_addr, tBT_TRANSPORT transport,
+                                void* p_ref_data, tBTM_STATUS result);
 typedef tBTM_SEC_CALLBACK tBTM_SEC_CALLBACK;
 
 /* Bond Cancel complete. Parameters are
diff --git a/system/stack/l2cap/l2c_ble.cc b/system/stack/l2cap/l2c_ble.cc
index d41c740394..9d4f4f491e 100644
--- a/system/stack/l2cap/l2c_ble.cc
+++ b/system/stack/l2cap/l2c_ble.cc
@@ -1248,15 +1248,14 @@ void l2cble_send_peer_disc_req(tL2C_CCB* p_ccb) {
  * Returns          void
  *
  ******************************************************************************/
-void l2cble_sec_comp(const RawAddress* bda, tBT_TRANSPORT transport,
+void l2cble_sec_comp(RawAddress bda, tBT_TRANSPORT transport,
                      void* /* p_ref_data */, tBTM_STATUS status) {
-  const RawAddress& p_bda = *bda;
-  tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(p_bda, BT_TRANSPORT_LE);
+  tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(bda, BT_TRANSPORT_LE);
   tL2CAP_SEC_DATA* p_buf = NULL;
   uint8_t sec_act;
 
   if (!p_lcb) {
-    log::warn("security complete for unknown device. bda={}", *bda);
+    log::warn("security complete for unknown device. bda={}", bda);
     return;
   }
 
@@ -1275,7 +1274,7 @@ void l2cble_sec_comp(const RawAddress* bda, tBT_TRANSPORT transport,
       osi_free(p_buf);
     } else {
       if (sec_act == BTM_SEC_ENCRYPT_MITM) {
-        if (BTM_IsLinkKeyAuthed(p_bda, transport))
+        if (BTM_IsLinkKeyAuthed(bda, transport))
           (*(p_buf->p_callback))(bda, BT_TRANSPORT_LE, p_buf->p_ref_data,
                                  status);
         else {
@@ -1304,8 +1303,8 @@ void l2cble_sec_comp(const RawAddress* bda, tBT_TRANSPORT transport,
       osi_free(p_buf);
     }
     else {
-      l2ble_sec_access_req(p_bda, p_buf->psm, p_buf->is_originator,
-          p_buf->p_callback, p_buf->p_ref_data);
+      l2ble_sec_access_req(bda, p_buf->psm, p_buf->is_originator,
+                           p_buf->p_callback, p_buf->p_ref_data);
 
       osi_free(p_buf);
       break;
@@ -1338,7 +1337,7 @@ tL2CAP_LE_RESULT_CODE l2ble_sec_access_req(const RawAddress& bd_addr,
 
   if (!p_lcb) {
     log::error("Security check for unknown device");
-    p_callback(&bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_UNKNOWN_ADDR);
+    p_callback(bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_UNKNOWN_ADDR);
     return L2CAP_LE_RESULT_NO_RESOURCES;
   }
 
@@ -1346,7 +1345,7 @@ tL2CAP_LE_RESULT_CODE l2ble_sec_access_req(const RawAddress& bd_addr,
       (tL2CAP_SEC_DATA*)osi_malloc((uint16_t)sizeof(tL2CAP_SEC_DATA));
   if (!p_buf) {
     log::error("No resources for connection");
-    p_callback(&bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_NO_RESOURCES);
+    p_callback(bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_NO_RESOURCES);
     return L2CAP_LE_RESULT_NO_RESOURCES;
   }
 
diff --git a/system/stack/l2cap/l2c_int.h b/system/stack/l2cap/l2c_int.h
index 9bddf3ef31..e441f6fdc6 100644
--- a/system/stack/l2cap/l2c_int.h
+++ b/system/stack/l2cap/l2c_int.h
@@ -818,7 +818,7 @@ void l2c_link_check_send_pkts(tL2C_LCB* p_lcb, uint16_t local_cid,
                               BT_HDR* p_buf);
 void l2c_link_adjust_allocation(void);
 
-void l2c_link_sec_comp(const RawAddress* p_bda, tBT_TRANSPORT trasnport,
+void l2c_link_sec_comp(RawAddress p_bda, tBT_TRANSPORT transport,
                        void* p_ref_data, tBTM_STATUS status);
 void l2c_link_adjust_chnl_allocation(void);
 
diff --git a/system/stack/l2cap/l2c_link.cc b/system/stack/l2cap/l2c_link.cc
index e1f86e7fea..68b7276d08 100644
--- a/system/stack/l2cap/l2c_link.cc
+++ b/system/stack/l2cap/l2c_link.cc
@@ -186,7 +186,7 @@ void l2c_link_hci_conn_comp(tHCI_STATUS status, uint16_t handle,
  * Returns          void
  *
  ******************************************************************************/
-void l2c_link_sec_comp(const RawAddress* p_bda, tBT_TRANSPORT transport,
+void l2c_link_sec_comp(RawAddress p_bda, tBT_TRANSPORT transport,
                        void* p_ref_data, tBTM_STATUS status) {
   tL2C_CONN_INFO ci;
   tL2C_LCB* p_lcb;
@@ -194,7 +194,7 @@ void l2c_link_sec_comp(const RawAddress* p_bda, tBT_TRANSPORT transport,
   tL2C_CCB* p_next_ccb;
 
   log::debug("btm_status={}, BD_ADDR={}, transport={}", btm_status_text(status),
-             *p_bda, bt_transport_text(transport));
+             p_bda, bt_transport_text(transport));
 
   if (status == BTM_SUCCESS_NO_SECURITY) {
     status = BTM_SUCCESS;
@@ -202,9 +202,9 @@ void l2c_link_sec_comp(const RawAddress* p_bda, tBT_TRANSPORT transport,
 
   /* Save the parameters */
   ci.status = status;
-  ci.bd_addr = *p_bda;
+  ci.bd_addr = p_bda;
 
-  p_lcb = l2cu_find_lcb_by_bd_addr(*p_bda, transport);
+  p_lcb = l2cu_find_lcb_by_bd_addr(p_bda, transport);
 
   /* If we don't have one, this is an error */
   if (!p_lcb) {
diff --git a/system/stack/l2cap/l2c_utils.cc b/system/stack/l2cap/l2c_utils.cc
index 910e27ff80..742f353ea8 100644
--- a/system/stack/l2cap/l2c_utils.cc
+++ b/system/stack/l2cap/l2c_utils.cc
@@ -217,7 +217,7 @@ void l2cu_release_lcb(tL2C_LCB* p_lcb) {
       tL2CAP_SEC_DATA* p_buf =
           (tL2CAP_SEC_DATA*)fixed_queue_try_dequeue(p_lcb->le_sec_pending_q);
       if (p_buf->p_callback)
-        p_buf->p_callback(&p_lcb->remote_bd_addr, p_lcb->transport,
+        p_buf->p_callback(p_lcb->remote_bd_addr, p_lcb->transport,
                           p_buf->p_ref_data, BTM_DEV_RESET);
       osi_free(p_buf);
     }
diff --git a/system/stack/rfcomm/rfc_int.h b/system/stack/rfcomm/rfc_int.h
index 52fa23948d..f223ccf6dd 100644
--- a/system/stack/rfcomm/rfc_int.h
+++ b/system/stack/rfcomm/rfc_int.h
@@ -237,7 +237,7 @@ tRFC_MCB* rfc_find_lcid_mcb(uint16_t lcid);
 void rfc_save_lcid_mcb(tRFC_MCB* p_rfc_mcb, uint16_t lcid);
 void rfc_check_mcb_active(tRFC_MCB* p_mcb);
 void rfc_port_closed(tPORT* p_port);
-void rfc_sec_check_complete(const RawAddress* bd_addr, tBT_TRANSPORT transport,
+void rfc_sec_check_complete(RawAddress bd_addr, tBT_TRANSPORT transport,
                             void* p_ref_data, tBTM_STATUS res);
 void rfc_inc_credit(tPORT* p_port, uint8_t credit);
 void rfc_dec_credit(tPORT* p_port);
diff --git a/system/stack/rfcomm/rfc_utils.cc b/system/stack/rfcomm/rfc_utils.cc
index b160580945..ccb21a82cb 100644
--- a/system/stack/rfcomm/rfc_utils.cc
+++ b/system/stack/rfcomm/rfc_utils.cc
@@ -317,7 +317,7 @@ void rfcomm_mcb_timer_timeout(void* data) {
  * Returns          void
  *
  ******************************************************************************/
-void rfc_sec_check_complete(const RawAddress* /* bd_addr */,
+void rfc_sec_check_complete(RawAddress /* bd_addr */,
                             tBT_TRANSPORT /* transport */, void* p_ref_data,
                             tBTM_STATUS res) {
   log::assert_that(p_ref_data != nullptr,
diff --git a/system/stack/test/rfcomm/stack_rfcomm_test.cc b/system/stack/test/rfcomm/stack_rfcomm_test.cc
index c8806b5749..a0c417605c 100644
--- a/system/stack/test/rfcomm/stack_rfcomm_test.cc
+++ b/system/stack/test/rfcomm/stack_rfcomm_test.cc
@@ -230,7 +230,7 @@ class StackRfcommTest : public Test {
     EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(ua_channel_dlci)))
         .WillOnce(Return(L2CAP_DW_SUCCESS));
     ASSERT_TRUE(security_callback);
-    security_callback(&peer_addr, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
+    security_callback(peer_addr, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
     osi_free(ua_channel_dlci);
 
     log::verbose("Step 4");
@@ -369,7 +369,7 @@ class StackRfcommTest : public Test {
     EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(sabm_channel_3)))
         .WillOnce(Return(L2CAP_DW_SUCCESS));
     ASSERT_TRUE(security_callback);
-    security_callback(&peer_addr, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
+    security_callback(peer_addr, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
     osi_free(sabm_channel_3);
 
     log::verbose("Step 4");
@@ -856,7 +856,7 @@ TEST_F(StackRfcommTest, DISABLED_TestConnectionCollision) {
   // in 20 seconds
   EXPECT_CALL(rfcomm_callback_,
               PortManagementCallback(PORT_SUCCESS, server_handle, 0));
-  security_callback(&test_address, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
+  security_callback(test_address, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
   osi_free(ua_server_scn);
 
   log::verbose("Step 11");