stack::rnr Introduce btm_stack_rnr_test

Bug: 349922552
Test: m .
Flag: EXEMPT, Test Infrastructure

Change-Id: I0b5b2fd413430d16e696a4ee02ab4bf8d5ed7445

22 files changed, 301 insertions, 236 deletions

diff --git a/system/bta/dm/bta_dm_device_search.cc b/system/bta/dm/bta_dm_device_search.cc
index 87094f4c45..9f8769fe9c 100644
--- a/system/bta/dm/bta_dm_device_search.cc
+++ b/system/bta/dm/bta_dm_device_search.cc
@@ -46,7 +46,6 @@
 #include "stack/include/btm_status.h"
 #include "stack/include/main_thread.h"
 #include "stack/include/rnr_interface.h"
-#include "stack/rnr/remote_name_request.h"
 #include "types/raw_address.h"
 
 using namespace bluetooth;
@@ -514,7 +513,7 @@ static void bta_dm_discover_name(const RawAddress& remote_bd_addr) {
     bta_dm_search_cb.name_discover_done = true;
   }
   // If we already have the name we can skip getting the name
-  if (BTM_IsRemoteNameKnown(remote_bd_addr, transport)) {
+  if (get_stack_rnr_interface().BTM_IsRemoteNameKnown(remote_bd_addr, transport)) {
     log::debug("Security record already known skipping read remote name peer:{}", remote_bd_addr);
     bta_dm_search_cb.name_discover_done = true;
   }
diff --git a/system/bta/dm/bta_dm_disc_legacy.cc b/system/bta/dm/bta_dm_disc_legacy.cc
index d607555404..5bac53bfad 100644
--- a/system/bta/dm/bta_dm_disc_legacy.cc
+++ b/system/bta/dm/bta_dm_disc_legacy.cc
@@ -405,8 +405,7 @@ static bool bta_dm_read_remote_device_name(const RawAddress& bd_addr, tBT_TRANSP
      * "bta_dm_remname_cback" */
     /* adding callback to get notified that current reading remote name done */
 
-    get_btm_client_interface().security.BTM_SecAddRmtNameNotifyCallback(
-            &bta_dm_service_search_remname_cback);
+    get_stack_rnr_interface().BTM_SecAddRmtNameNotifyCallback(&bta_dm_service_search_remname_cback);
 
     return true;
   } else {
@@ -697,7 +696,7 @@ static void bta_dm_sdp_result(tBTA_DM_SDP_RESULT& sdp_event) {
       /* callbacks */
       /* start next bd_addr if necessary */
 
-      get_btm_client_interface().security.BTM_SecDeleteRmtNameNotifyCallback(
+      get_stack_rnr_interface().BTM_SecDeleteRmtNameNotifyCallback(
               &bta_dm_service_search_remname_cback);
 
       BTM_LogHistory(
@@ -753,7 +752,7 @@ static void bta_dm_sdp_result(tBTA_DM_SDP_RESULT& sdp_event) {
       osi_free_and_reset((void**)&bta_dm_search_cb.p_sdp_db);
     }
 
-    get_btm_client_interface().security.BTM_SecDeleteRmtNameNotifyCallback(
+    get_stack_rnr_interface().BTM_SecDeleteRmtNameNotifyCallback(
             &bta_dm_service_search_remname_cback);
 
     auto msg = std::make_unique<tBTA_DM_MSG>(tBTA_DM_SVC_RES{});
@@ -1160,7 +1159,7 @@ static void bta_dm_discover_name(const RawAddress& remote_bd_addr) {
     bta_dm_search_cb.name_discover_done = true;
   }
   // If we already have the name we can skip getting the name
-  if (BTM_IsRemoteNameKnown(remote_bd_addr, transport)) {
+  if (get_stack_rnr_interface().BTM_IsRemoteNameKnown(remote_bd_addr, transport)) {
     log::debug("Security record already known skipping read remote name peer:{}", remote_bd_addr);
     bta_dm_search_cb.name_discover_done = true;
   }
@@ -1429,14 +1428,14 @@ static void bta_dm_remname_cback(const tBTM_REMOTE_DEV_NAME* p_remote_name) {
           strnlen((const char*)p_remote_name->remote_bd_name, BD_NAME_LEN));
 
   if (bta_dm_search_cb.peer_bdaddr == p_remote_name->bd_addr) {
-    get_btm_client_interface().security.BTM_SecDeleteRmtNameNotifyCallback(
+    get_stack_rnr_interface().BTM_SecDeleteRmtNameNotifyCallback(
             &bta_dm_service_search_remname_cback);
   } else {
     // if we got a different response, maybe ignore it
     // we will have made a request directly from BTM_ReadRemoteDeviceName so we
     // expect a dedicated response for us
     if (p_remote_name->hci_status == HCI_ERR_CONNECTION_EXISTS) {
-      get_btm_client_interface().security.BTM_SecDeleteRmtNameNotifyCallback(
+      get_stack_rnr_interface().BTM_SecDeleteRmtNameNotifyCallback(
               &bta_dm_service_search_remname_cback);
       log::info("Assume command failed due to disconnection hci_status:{} peer:{}",
                 hci_error_code_text(p_remote_name->hci_status), p_remote_name->bd_addr);
diff --git a/system/btif/src/btif_dm.cc b/system/btif/src/btif_dm.cc
index 9ef4e6c937..378484ad9a 100644
--- a/system/btif/src/btif_dm.cc
+++ b/system/btif/src/btif_dm.cc
@@ -94,6 +94,7 @@
 #include "stack/include/btm_log_history.h"
 #include "stack/include/btm_sec_api.h"
 #include "stack/include/btm_sec_api_types.h"
+#include "stack/include/rnr_interface.h"
 #include "stack/include/smp_api.h"
 #include "stack/include/srvc_api.h"  // tDIS_VALUE
 #include "storage/config_keys.h"
@@ -1973,7 +1974,7 @@ void BTIF_dm_enable() {
   BTA_DmBleConfigLocalPrivacy(ble_privacy_enabled);
 
   if (com::android::bluetooth::flags::separate_service_and_device_discovery()) {
-    get_security_client_interface().BTM_SecAddRmtNameNotifyCallback(btif_on_name_read_from_btm);
+    get_stack_rnr_interface().BTM_SecAddRmtNameNotifyCallback(btif_on_name_read_from_btm);
   }
 
   /* for each of the enabled services in the mask, trigger the profile
@@ -2001,7 +2002,7 @@ void BTIF_dm_enable() {
 
 void BTIF_dm_disable() {
   if (com::android::bluetooth::flags::separate_service_and_device_discovery()) {
-    get_security_client_interface().BTM_SecDeleteRmtNameNotifyCallback(&btif_on_name_read_from_btm);
+    get_stack_rnr_interface().BTM_SecDeleteRmtNameNotifyCallback(&btif_on_name_read_from_btm);
   }
 
   /* for each of the enabled services in the mask, trigger the profile
diff --git a/system/main/Android.bp b/system/main/Android.bp
index e359069c95..4e4ec7c936 100644
--- a/system/main/Android.bp
+++ b/system/main/Android.bp
@@ -287,6 +287,7 @@ cc_test {
         ":TestMockLegacyHciCommands",
         ":TestMockLegacyHciInterface",
         ":TestMockStack",
+        ":TestMockStackRnr",
         "test/main_shim_stack_dumpsys_test.cc",
     ],
     static_libs: [
diff --git a/system/main/shim/acl_api.cc b/system/main/shim/acl_api.cc
index 2b5d2669ad..d00a6619b4 100644
--- a/system/main/shim/acl_api.cc
+++ b/system/main/shim/acl_api.cc
@@ -36,6 +36,7 @@
 #include "stack/btm/security_device_record.h"
 #include "stack/include/bt_hdr.h"
 #include "stack/include/main_thread.h"
+#include "stack/include/rnr_interface.h"
 #include "stack/rnr/remote_name_request.h"
 #include "types/ble_address_with_type.h"
 #include "types/raw_address.h"
@@ -203,8 +204,8 @@ void bluetooth::shim::ACL_RemoteNameRequest(const RawAddress& addr, uint8_t page
                         // 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));
+                        get_stack_rnr_interface().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));
                       },
@@ -220,16 +221,16 @@ void bluetooth::shim::ACL_RemoteNameRequest(const RawAddress& addr, uint8_t page
                   addr),
           GetGdShimHandler()->BindOnce(
                   [](RawAddress addr, hci::ErrorCode status, std::array<uint8_t, 248> name) {
-                    do_in_main_thread(
-                            base::BindOnce(
-                                    [](RawAddress addr, hci::ErrorCode status,
-                                       std::array<uint8_t, 248> name) {
-                                      btm_process_remote_name(&addr, name.data(), name.size(),
-                                                              static_cast<tHCI_STATUS>(status));
-                                      btm_sec_rmt_name_request_complete(
-                                              &addr, name.data(), static_cast<tHCI_STATUS>(status));
-                                    },
-                                    addr, status, name));
+                    do_in_main_thread(base::BindOnce(
+                            [](RawAddress addr, hci::ErrorCode status,
+                               std::array<uint8_t, 248> name) {
+                              get_stack_rnr_interface().btm_process_remote_name(
+                                      &addr, name.data(), name.size(),
+                                      static_cast<tHCI_STATUS>(status));
+                              btm_sec_rmt_name_request_complete(&addr, name.data(),
+                                                                static_cast<tHCI_STATUS>(status));
+                            },
+                            addr, status, name));
                   },
                   addr));
 }
diff --git a/system/stack/Android.bp b/system/stack/Android.bp
index 84c7015983..0b18ced515 100644
--- a/system/stack/Android.bp
+++ b/system/stack/Android.bp
@@ -1656,6 +1656,7 @@ cc_test {
         ":TestMockStackGatt",
         ":TestMockStackHcic",
         ":TestMockStackL2cap",
+        ":TestMockStackRnr",
         ":TestMockStackSmp",
         ":TestMockUdrv",
         "acl/acl.cc",
@@ -1691,7 +1692,6 @@ cc_test {
         "btm/hfp_msbc_encoder.cc",
         "btm/security_event_parser.cc",
         "metrics/stack_metrics_logging.cc",
-        "rnr/remote_name_request.cc",
         "test/btm/peer_packet_types_test.cc",
         "test/btm/sco_hci_test.cc",
         "test/btm/sco_pkt_status_test.cc",
@@ -2229,6 +2229,104 @@ cc_test {
     cflags: ["-Wno-unused-parameter"],
 }
 
+cc_test {
+    name: "net_test_stack_rnr",
+    test_suites: ["general-tests"],
+    host_supported: true,
+    test_options: {
+        unit_test: true,
+    },
+    defaults: [
+        "bluetooth_flatbuffer_bundler_defaults",
+        "fluoride_defaults",
+        "mts_defaults",
+    ],
+    local_include_dirs: [
+        "btm",
+        "include",
+        "test/common",
+    ],
+    include_dirs: [
+        "packages/modules/Bluetooth/system",
+        "packages/modules/Bluetooth/system/device/include",
+        "packages/modules/Bluetooth/system/gd",
+    ],
+    generated_headers: [
+        "BluetoothGeneratedDumpsysDataSchema_h",
+    ],
+    srcs: [
+        ":BluetoothHalSources_hci_host",
+        ":BluetoothHalSources_ranging_host",
+        ":BluetoothHciFake",
+        ":BluetoothOsSources_host",
+        ":OsiCompatSources",
+        ":TestCommonMainHandler",
+        ":TestCommonMockFunctions",
+        ":TestCommonStackConfig",
+        ":TestFakeLooper",
+        ":TestFakeOsi",
+        ":TestFakeThread",
+        ":TestMockBta",
+        ":TestMockBtif",
+        ":TestMockDevice",
+        ":TestMockLegacyHciInterface",
+        ":TestMockMainBte",
+        ":TestMockMainShim",
+        ":TestMockMainShimEntry",
+        ":TestMockRustFfi",
+        ":TestMockStackBtm",
+        ":TestMockStackBtu",
+        ":TestMockStackGap",
+        ":TestMockStackGatt",
+        ":TestMockStackHcic",
+        ":TestMockStackL2cap",
+        ":TestMockStackSmp",
+        ":TestMockUdrv",
+        "rnr/remote_name_request.cc",
+        "test/stack_rnr_test.cc",
+    ],
+    static_libs: [
+        "bluetooth_flags_c_lib",
+        "libbase",
+        "libbluetooth-types",
+        "libbluetooth_crypto_toolbox",
+        "libbluetooth_gd",
+        "libbluetooth_log",
+        "libbt-common",
+        "libbt-platform-protos-lite",
+        "libbt-sbc-decoder",
+        "libbt-sbc-encoder",
+        "libbt_shim_bridge",
+        "libbt_shim_ffi",
+        "libbtdevice",
+        "libchrome",
+        "libcom.android.sysprop.bluetooth.wrapped",
+        "libevent",
+        "libgmock",
+        "liblc3",
+        "liblog",
+        "libosi",
+        "libprotobuf-cpp-lite",
+        "libudrv-uipc",
+    ],
+    shared_libs: [
+        "libaconfig_storage_read_api_cc",
+        "libcrypto",
+        "server_configurable_flags",
+    ],
+    sanitize: {
+        address: true,
+        all_undefined: true,
+        cfi: true,
+        integer_overflow: true,
+        scs: true,
+        diag: {
+            undefined: true,
+        },
+    },
+    header_libs: ["libbluetooth_headers"],
+}
+
 // Bluetooth stack connection multiplexing
 cc_test {
     name: "net_test_stack_sdp",
diff --git a/system/stack/btm/btm_ble_gap.cc b/system/stack/btm/btm_ble_gap.cc
index fe3a650b2e..f73e9bf269 100644
--- a/system/stack/btm/btm_ble_gap.cc
+++ b/system/stack/btm/btm_ble_gap.cc
@@ -1604,7 +1604,7 @@ void btm_ble_read_remote_name_cmpl(bool status, const RawAddress& bda, uint16_t
     hci_status = HCI_ERR_HOST_TIMEOUT;
   }
 
-  btm_process_remote_name(&bda, bd_name, length + 1, hci_status);
+  get_stack_rnr_interface().btm_process_remote_name(&bda, bd_name, length + 1, hci_status);
   btm_sec_rmt_name_request_complete(&bda, (const uint8_t*)p_name, hci_status);
 }
 
diff --git a/system/stack/btm/btm_sec.h b/system/stack/btm/btm_sec.h
index 798267249b..c8a2e16c61 100644
--- a/system/stack/btm/btm_sec.h
+++ b/system/stack/btm/btm_sec.h
@@ -55,30 +55,6 @@
  ******************************************************************************/
 bool BTM_SecRegister(const tBTM_APPL_INFO* p_cb_info);
 
-/*******************************************************************************
- *
- * Function         BTM_SecAddRmtNameNotifyCallback
- *
- * Description      Any profile can register to be notified when name of the
- *                  remote device is resolved.
- *
- * Returns          true if registered OK, else false
- *
- ******************************************************************************/
-bool BTM_SecAddRmtNameNotifyCallback(tBTM_RMT_NAME_CALLBACK* p_callback);
-
-/*******************************************************************************
- *
- * Function         BTM_SecDeleteRmtNameNotifyCallback
- *
- * Description      Any profile can deregister notification when a new Link Key
- *                  is generated per connection.
- *
- * Returns          true if OK, else false
- *
- ******************************************************************************/
-bool BTM_SecDeleteRmtNameNotifyCallback(tBTM_RMT_NAME_CALLBACK* p_callback);
-
 bool BTM_IsEncrypted(const RawAddress& bd_addr, tBT_TRANSPORT transport);
 bool BTM_IsLinkKeyAuthed(const RawAddress& bd_addr, tBT_TRANSPORT transport);
 bool BTM_IsLinkKeyKnown(const RawAddress& bd_addr, tBT_TRANSPORT transport);
diff --git a/system/stack/btm/btm_security_client_interface.cc b/system/stack/btm/btm_security_client_interface.cc
index 9e7f6a822b..a4a0750382 100644
--- a/system/stack/btm/btm_security_client_interface.cc
+++ b/system/stack/btm/btm_security_client_interface.cc
@@ -73,8 +73,6 @@ static SecurityClientInterface security = {
         .BTM_GetSecurityMode = BTM_GetSecurityMode,
 
         .BTM_SecReadDevName = BTM_SecReadDevName,
-        .BTM_SecAddRmtNameNotifyCallback = BTM_SecAddRmtNameNotifyCallback,
-        .BTM_SecDeleteRmtNameNotifyCallback = BTM_SecDeleteRmtNameNotifyCallback,
 };
 
 const SecurityClientInterface& get_security_client_interface() { return security; }
diff --git a/system/stack/include/security_client_callbacks.h b/system/stack/include/security_client_callbacks.h
index 1e776c5ac2..9bc11f4098 100644
--- a/system/stack/include/security_client_callbacks.h
+++ b/system/stack/include/security_client_callbacks.h
@@ -141,8 +141,6 @@ typedef struct {
   // remote name request related APIs
   // TODO: remove them from this structure
   const char* (*BTM_SecReadDevName)(const RawAddress& bd_addr);
-  bool (*BTM_SecAddRmtNameNotifyCallback)(tBTM_RMT_NAME_CALLBACK* p_callback);
-  bool (*BTM_SecDeleteRmtNameNotifyCallback)(tBTM_RMT_NAME_CALLBACK* p_callback);
 } SecurityClientInterface;
 
 const SecurityClientInterface& get_security_client_interface();
diff --git a/system/stack/test/btm/btm_test_fixtures.h b/system/stack/test/btm/btm_test_fixtures.h
index 27d6648053..5343753877 100644
--- a/system/stack/test/btm/btm_test_fixtures.h
+++ b/system/stack/test/btm/btm_test_fixtures.h
@@ -20,6 +20,7 @@
 
 #include "test/common/mock_functions.h"
 #include "test/fake/fake_osi.h"
+#include "test/mock/mock_stack_rnr_interface.h"
 
 class BtmWithFakesTest : public testing::Test {
 protected:
@@ -35,7 +36,10 @@ protected:
   void SetUp() override {
     BtmWithFakesTest::SetUp();
     reset_mock_function_count_map();
+    bluetooth::testing::stack::rnr::set_interface(&mock_stack_rnr_interface_);
   }
 
   void TearDown() override { BtmWithFakesTest::TearDown(); }
+
+  bluetooth::testing::stack::rnr::Mock mock_stack_rnr_interface_;
 };
diff --git a/system/stack/test/btm/stack_btm_inq_test.cc b/system/stack/test/btm/stack_btm_inq_test.cc
index cad4b328d9..6262915a2c 100644
--- a/system/stack/test/btm/stack_btm_inq_test.cc
+++ b/system/stack/test/btm/stack_btm_inq_test.cc
@@ -109,78 +109,6 @@ protected:
   void TearDown() override { BtmInqTest::TearDown(); }
 };
 
-TEST_F(BtmInqActiveTest, btm_process_remote_name__typical) {
-  btm_process_remote_name(&kRawAddress, kBdName, 0, HCI_SUCCESS);
-  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
-  ASSERT_FALSE(btm_cb.rnr.remname_active);
-  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
-  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
-  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
-
-  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
-  ASSERT_EQ(tBTM_STATUS::BTM_SUCCESS, gBTM_REMOTE_DEV_NAME.btm_status);
-  ASSERT_EQ(HCI_SUCCESS, gBTM_REMOTE_DEV_NAME.hci_status);
-  ASSERT_EQ(kRawAddress, gBTM_REMOTE_DEV_NAME.bd_addr);
-  ASSERT_STREQ((char*)kBdName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
-}
-
-TEST_F(BtmInqActiveTest, btm_process_remote_name__no_name) {
-  btm_process_remote_name(&kRawAddress, nullptr, 0, HCI_SUCCESS);
-  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
-  ASSERT_FALSE(btm_cb.rnr.remname_active);
-  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
-  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
-  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
-
-  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
-  ASSERT_EQ(tBTM_STATUS::BTM_SUCCESS, gBTM_REMOTE_DEV_NAME.btm_status);
-  ASSERT_EQ(HCI_SUCCESS, gBTM_REMOTE_DEV_NAME.hci_status);
-  ASSERT_EQ(kRawAddress, gBTM_REMOTE_DEV_NAME.bd_addr);
-  ASSERT_STREQ((char*)kEmptyName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
-}
-
-TEST_F(BtmInqActiveTest, btm_process_remote_name__bad_status) {
-  btm_process_remote_name(&kRawAddress, kBdName, 0, HCI_ERR_PAGE_TIMEOUT);
-  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
-  ASSERT_FALSE(btm_cb.rnr.remname_active);
-  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
-  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
-  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
-
-  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
-  ASSERT_EQ(tBTM_STATUS::BTM_BAD_VALUE_RET, gBTM_REMOTE_DEV_NAME.btm_status);
-  ASSERT_EQ(HCI_ERR_PAGE_TIMEOUT, gBTM_REMOTE_DEV_NAME.hci_status);
-  ASSERT_EQ(kRawAddress, gBTM_REMOTE_DEV_NAME.bd_addr);
-  ASSERT_STREQ((char*)kEmptyName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
-}
-
-TEST_F(BtmInqActiveTest, btm_process_remote_name__no_address) {
-  btm_process_remote_name(nullptr, kBdName, 0, HCI_SUCCESS);
-  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
-  ASSERT_FALSE(btm_cb.rnr.remname_active);
-  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
-  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
-  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
-
-  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
-  ASSERT_EQ(tBTM_STATUS::BTM_SUCCESS, gBTM_REMOTE_DEV_NAME.btm_status);
-  ASSERT_EQ(HCI_SUCCESS, gBTM_REMOTE_DEV_NAME.hci_status);
-  ASSERT_EQ(RawAddress::kEmpty, gBTM_REMOTE_DEV_NAME.bd_addr);
-  ASSERT_STREQ((char*)kBdName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
-}
-
-TEST_F(BtmInqActiveTest, btm_process_remote_name__different_address) {
-  btm_cb.rnr.remname_bda = kRawAddress2;
-  btm_process_remote_name(&kRawAddress, kBdName, 0, HCI_SUCCESS);
-  ASSERT_TRUE(btm_cb.rnr.p_remname_cmpl_cb);
-  ASSERT_TRUE(btm_cb.rnr.remname_active);
-  ASSERT_NE(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
-  ASSERT_NE(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
-  ASSERT_EQ(0, get_func_call_count("alarm_cancel"));
-
-  ASSERT_FALSE(gBTM_REMOTE_DEV_NAME_sent);
-}
-
 class BtmInquiryCallbacks {
 public:
   virtual ~BtmInquiryCallbacks() = default;
diff --git a/system/stack/test/btm/stack_btm_sec_test.cc b/system/stack/test/btm/stack_btm_sec_test.cc
index 13c784b065..bb81d7703d 100644
--- a/system/stack/test/btm/stack_btm_sec_test.cc
+++ b/system/stack/test/btm/stack_btm_sec_test.cc
@@ -37,8 +37,8 @@ extern tBTM_CB btm_cb;
 
 using namespace bluetooth;
 
-using testing::Return;
-using testing::Test;
+using ::testing::Return;
+using ::testing::Test;
 
 namespace {
 const RawAddress kRawAddress = RawAddress({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
diff --git a/system/stack/test/btm/stack_btm_test.cc b/system/stack/test/btm/stack_btm_test.cc
index 7400a97494..aeaaf68913 100644
--- a/system/stack/test/btm/stack_btm_test.cc
+++ b/system/stack/test/btm/stack_btm_test.cc
@@ -38,13 +38,17 @@
 #include "test/mock/mock_main_shim_entry.h"
 #include "types/raw_address.h"
 
-using testing::Each;
-using testing::Eq;
+using ::testing::_;
+using ::testing::Each;
+using ::testing::Eq;
+using ::testing::Invoke;
 
 extern tBTM_CB btm_cb;
 
 tL2C_CB l2cb;
 
+void btm_inq_remote_name_timer_timeout(void*) {}
+
 const std::string kSmpOptions("mock smp options");
 const std::string kBroadcastAudioConfigOptions("mock broadcast audio config options");
 
@@ -80,6 +84,8 @@ protected:
     bluetooth::hci::testing::mock_hci_layer_ = &mock_hci_;
     bluetooth::hci::testing::mock_gd_shim_handler_ = up_handler_;
     bluetooth::legacy::hci::testing::SetMock(legacy_hci_mock_);
+    EXPECT_CALL(mock_hci_, RegisterForScoConnectionRequests(_));
+    EXPECT_CALL(mock_hci_, RegisterForDisconnects(_));
   }
   void TearDown() override {
     up_handler_->Clear();
@@ -105,7 +111,6 @@ protected:
   void SetUp() override {
     StackBtmWithQueuesTest::SetUp();
     EXPECT_CALL(mock_hci_, GetScoQueueEnd()).WillOnce(Return(sco_queue_.GetUpEnd()));
-
     btm_cb.Init();
     btm_sec_cb.Init(BTM_SEC_MODE_SC);
   }
@@ -217,13 +222,16 @@ struct {
   BD_NAME bd_name;
 } btm_test;
 
+namespace {
+void BTM_RMT_NAME_CALLBACK(const RawAddress& bd_addr, DEV_CLASS dc, BD_NAME bd_name) {
+  btm_test.bd_addr = bd_addr;
+  btm_test.dc = dc;
+  memcpy(btm_test.bd_name, bd_name, BD_NAME_LEN);
+}
+}  // namespace
+
 TEST_F(StackBtmWithInitFreeTest, btm_sec_rmt_name_request_complete) {
-  ASSERT_TRUE(BTM_SecAddRmtNameNotifyCallback(
-          [](const RawAddress& bd_addr, DEV_CLASS dc, BD_NAME bd_name) {
-            btm_test.bd_addr = bd_addr;
-            btm_test.dc = dc;
-            memcpy(btm_test.bd_name, bd_name, BD_NAME_LEN);
-          }));
+  btm_cb.rnr.p_rmt_name_callback[0] = BTM_RMT_NAME_CALLBACK;
 
   RawAddress bd_addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
   const uint8_t* p_bd_name = (const uint8_t*)"MyTestName";
diff --git a/system/stack/test/stack_rnr_test.cc b/system/stack/test/stack_rnr_test.cc
new file mode 100644
index 0000000000..0299e1574f
--- /dev/null
+++ b/system/stack/test/stack_rnr_test.cc
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <bluetooth/log.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "hci/hci_layer_fake.h"
+#include "stack/btm/btm_int_types.h"
+#include "stack/include/hci_error_code.h"
+#include "stack/test/btm/btm_test_fixtures.h"
+#include "test/fake/fake_looper.h"
+#include "test/mock/mock_osi_allocator.h"
+#include "test/mock/mock_osi_thread.h"
+#include "types/raw_address.h"
+
+extern tBTM_CB btm_cb;
+
+bool ble_evt_type_is_connectable(uint16_t /* evt_type */) { return true; }
+
+tBTM_CB btm_cb;
+
+namespace {
+const RawAddress kRawAddress = RawAddress({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
+const RawAddress kRawAddress2 = RawAddress({0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc});
+const BD_NAME kBdName = {'A', ' ', 'B', 'd', ' ', 'N', 'a', 'm', 'e', '\0'};
+const BD_NAME kEmptyName = "";
+
+tBTM_REMOTE_DEV_NAME gBTM_REMOTE_DEV_NAME{};
+bool gBTM_REMOTE_DEV_NAME_sent{false};
+
+static constexpr uint8_t kNumCommandPackets = 1;
+
+}  // namespace
+
+class BtmRnrTest : public ::testing::Test {
+protected:
+  void SetUp() override {
+    reset_mock_function_count_map();
+    fake_osi_ = std::make_unique<test::fake::FakeOsi>();
+    btm_cb = {};
+  }
+
+  void TearDown() override { fake_osi_.reset(); }
+
+  std::unique_ptr<test::fake::FakeOsi> fake_osi_;
+};
+
+class BtmRnrActiveTest : public BtmRnrTest {
+protected:
+  void SetUp() override {
+    BtmRnrTest::SetUp();
+    gBTM_REMOTE_DEV_NAME = {};
+    gBTM_REMOTE_DEV_NAME_sent = false;
+
+    btm_cb.rnr.remname_active = true;
+    btm_cb.rnr.remname_bda = kRawAddress;
+    btm_cb.rnr.remname_dev_type = BT_DEVICE_TYPE_BREDR;
+    btm_cb.rnr.p_remname_cmpl_cb = [](const tBTM_REMOTE_DEV_NAME* name) {
+      gBTM_REMOTE_DEV_NAME = *name;
+      gBTM_REMOTE_DEV_NAME_sent = true;
+    };
+  }
+
+  void TearDown() override { BtmRnrTest::TearDown(); }
+};
+
+TEST_F(BtmRnrActiveTest, btm_process_remote_name__typical) {
+  btm_process_remote_name(&kRawAddress, kBdName, 0, HCI_SUCCESS);
+  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
+  ASSERT_FALSE(btm_cb.rnr.remname_active);
+  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
+  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
+  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
+
+  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
+  ASSERT_EQ(tBTM_STATUS::BTM_SUCCESS, gBTM_REMOTE_DEV_NAME.btm_status);
+  ASSERT_EQ(HCI_SUCCESS, gBTM_REMOTE_DEV_NAME.hci_status);
+  ASSERT_EQ(kRawAddress, gBTM_REMOTE_DEV_NAME.bd_addr);
+  ASSERT_STREQ((char*)kBdName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
+}
+
+TEST_F(BtmRnrActiveTest, btm_process_remote_name__no_name) {
+  btm_process_remote_name(&kRawAddress, nullptr, 0, HCI_SUCCESS);
+  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
+  ASSERT_FALSE(btm_cb.rnr.remname_active);
+  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
+  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
+  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
+
+  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
+  ASSERT_EQ(tBTM_STATUS::BTM_SUCCESS, gBTM_REMOTE_DEV_NAME.btm_status);
+  ASSERT_EQ(HCI_SUCCESS, gBTM_REMOTE_DEV_NAME.hci_status);
+  ASSERT_EQ(kRawAddress, gBTM_REMOTE_DEV_NAME.bd_addr);
+  ASSERT_STREQ((char*)kEmptyName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
+}
+
+TEST_F(BtmRnrActiveTest, btm_process_remote_name__bad_status) {
+  btm_process_remote_name(&kRawAddress, kBdName, 0, HCI_ERR_PAGE_TIMEOUT);
+  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
+  ASSERT_FALSE(btm_cb.rnr.remname_active);
+  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
+  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
+  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
+
+  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
+  ASSERT_EQ(tBTM_STATUS::BTM_BAD_VALUE_RET, gBTM_REMOTE_DEV_NAME.btm_status);
+  ASSERT_EQ(HCI_ERR_PAGE_TIMEOUT, gBTM_REMOTE_DEV_NAME.hci_status);
+  ASSERT_EQ(kRawAddress, gBTM_REMOTE_DEV_NAME.bd_addr);
+  ASSERT_STREQ((char*)kEmptyName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
+}
+
+TEST_F(BtmRnrActiveTest, btm_process_remote_name__no_address) {
+  btm_process_remote_name(nullptr, kBdName, 0, HCI_SUCCESS);
+  ASSERT_FALSE(btm_cb.rnr.p_remname_cmpl_cb);
+  ASSERT_FALSE(btm_cb.rnr.remname_active);
+  ASSERT_EQ(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
+  ASSERT_EQ(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
+  ASSERT_EQ(1, get_func_call_count("alarm_cancel"));
+
+  ASSERT_TRUE(gBTM_REMOTE_DEV_NAME_sent);
+  ASSERT_EQ(tBTM_STATUS::BTM_SUCCESS, gBTM_REMOTE_DEV_NAME.btm_status);
+  ASSERT_EQ(HCI_SUCCESS, gBTM_REMOTE_DEV_NAME.hci_status);
+  ASSERT_EQ(RawAddress::kEmpty, gBTM_REMOTE_DEV_NAME.bd_addr);
+  ASSERT_STREQ((char*)kBdName, (char*)gBTM_REMOTE_DEV_NAME.remote_bd_name);
+}
+
+TEST_F(BtmRnrActiveTest, btm_process_remote_name__different_address) {
+  btm_cb.rnr.remname_bda = kRawAddress2;
+  btm_process_remote_name(&kRawAddress, kBdName, 0, HCI_SUCCESS);
+  ASSERT_TRUE(btm_cb.rnr.p_remname_cmpl_cb);
+  ASSERT_TRUE(btm_cb.rnr.remname_active);
+  ASSERT_NE(btm_cb.rnr.remname_bda, RawAddress::kEmpty);
+  ASSERT_NE(btm_cb.rnr.remname_dev_type, BT_DEVICE_TYPE_UNKNOWN);
+  ASSERT_EQ(0, get_func_call_count("alarm_cancel"));
+
+  ASSERT_FALSE(gBTM_REMOTE_DEV_NAME_sent);
+}
diff --git a/system/test/mock/mock_stack_btm_ble_gap.cc b/system/test/mock/mock_stack_btm_ble_gap.cc
index bfb7870778..2e5ccc456f 100644
--- a/system/test/mock/mock_stack_btm_ble_gap.cc
+++ b/system/test/mock/mock_stack_btm_ble_gap.cc
@@ -25,9 +25,9 @@
 #include "stack/btm/btm_ble_int.h"
 #include "stack/btm/btm_ble_int_types.h"
 #include "stack/include/bt_dev_class.h"
-#include "stack/include/btm_api_types.h"
 #include "stack/include/btm_status.h"
 #include "stack/include/hci_error_code.h"
+#include "stack/include/rnr_interface.h"
 #include "test/common/mock_functions.h"
 #include "types/ble_address_with_type.h"
 #include "types/raw_address.h"
@@ -75,7 +75,8 @@ void BTM_BleOpportunisticObserve(bool /* enable */, tBTM_INQ_RESULTS_CB* /* p_re
 void BTM_BleTargetAnnouncementObserve(bool /* enable */, tBTM_INQ_RESULTS_CB* /* p_results_cb */) {
   inc_func_call_count(__func__);
 }
-tBTM_STATUS btm_ble_read_remote_name(const RawAddress& /* remote_bda */, tBTM_CMPL_CB* /* p_cb */) {
+tBTM_STATUS btm_ble_read_remote_name(const RawAddress& /* remote_bda */,
+                                     tBTM_NAME_CMPL_CB* /* p_cb */) {
   inc_func_call_count(__func__);
   return tBTM_STATUS::BTM_SUCCESS;
 }
diff --git a/system/test/mock/mock_stack_btm_inq.cc b/system/test/mock/mock_stack_btm_inq.cc
index 06b0738d1c..82fd00d2b1 100644
--- a/system/test/mock/mock_stack_btm_inq.cc
+++ b/system/test/mock/mock_stack_btm_inq.cc
@@ -52,10 +52,7 @@ struct btm_inq_db_find btm_inq_db_find;
 struct btm_inq_db_new btm_inq_db_new;
 struct btm_inq_db_reset btm_inq_db_reset;
 struct btm_inq_find_bdaddr btm_inq_find_bdaddr;
-struct btm_inq_remote_name_timer_timeout btm_inq_remote_name_timer_timeout;
-struct btm_inq_rmt_name_failed_cancelled btm_inq_rmt_name_failed_cancelled;
 struct btm_process_inq_complete btm_process_inq_complete;
-struct btm_process_remote_name btm_process_remote_name;
 struct btm_set_eir_uuid btm_set_eir_uuid;
 struct btm_sort_inq_result btm_sort_inq_result;
 
@@ -147,23 +144,10 @@ bool btm_inq_find_bdaddr(const RawAddress& p_bda) {
   inc_func_call_count(__func__);
   return test::mock::stack_btm_inq::btm_inq_find_bdaddr(p_bda);
 }
-void btm_inq_remote_name_timer_timeout(void* data) {
-  inc_func_call_count(__func__);
-  test::mock::stack_btm_inq::btm_inq_remote_name_timer_timeout(data);
-}
-void btm_inq_rmt_name_failed_cancelled(void) {
-  inc_func_call_count(__func__);
-  test::mock::stack_btm_inq::btm_inq_rmt_name_failed_cancelled();
-}
 void btm_process_inq_complete(tHCI_STATUS status, uint8_t mode) {
   inc_func_call_count(__func__);
   test::mock::stack_btm_inq::btm_process_inq_complete(status, mode);
 }
-void btm_process_remote_name(const RawAddress* bda, const BD_NAME bdn, uint16_t evt_len,
-                             tHCI_STATUS hci_status) {
-  inc_func_call_count(__func__);
-  test::mock::stack_btm_inq::btm_process_remote_name(bda, bdn, evt_len, hci_status);
-}
 void btm_set_eir_uuid(const uint8_t* p_eir, tBTM_INQ_RESULTS* p_results) {
   inc_func_call_count(__func__);
   test::mock::stack_btm_inq::btm_set_eir_uuid(p_eir, p_results);
diff --git a/system/test/mock/mock_stack_btm_inq.h b/system/test/mock/mock_stack_btm_inq.h
index 76dbd069c3..d89dd534c2 100644
--- a/system/test/mock/mock_stack_btm_inq.h
+++ b/system/test/mock/mock_stack_btm_inq.h
@@ -212,24 +212,6 @@ struct btm_inq_find_bdaddr {
 };
 extern struct btm_inq_find_bdaddr btm_inq_find_bdaddr;
 
-// Name: btm_inq_remote_name_timer_timeout
-// Params:  void* data
-// Return: void
-struct btm_inq_remote_name_timer_timeout {
-  std::function<void(void* data)> body{[](void* /* data */) {}};
-  void operator()(void* data) { body(data); }
-};
-extern struct btm_inq_remote_name_timer_timeout btm_inq_remote_name_timer_timeout;
-
-// Name: btm_inq_rmt_name_failed_cancelled
-// Params: void
-// Return: void
-struct btm_inq_rmt_name_failed_cancelled {
-  std::function<void(void)> body{[](void) {}};
-  void operator()(void) { body(); }
-};
-extern struct btm_inq_rmt_name_failed_cancelled btm_inq_rmt_name_failed_cancelled;
-
 // Name: btm_process_inq_complete
 // Params: tHCI_STATUS status, uint8_t mode
 // Return: void
@@ -240,21 +222,6 @@ struct btm_process_inq_complete {
 };
 extern struct btm_process_inq_complete btm_process_inq_complete;
 
-// Name: btm_process_remote_name
-// Params: const RawAddress* bda, const BD_NAME bdn, uint16_t evt_len,
-// tHCI_STATUS hci_status Return: void
-struct btm_process_remote_name {
-  std::function<void(const RawAddress* bda, const BD_NAME bdn, uint16_t evt_len,
-                     tHCI_STATUS hci_status)>
-          body{[](const RawAddress* /* bda */, const BD_NAME /* bdn */, uint16_t /* evt_len */,
-                  tHCI_STATUS /* hci_status */) {}};
-  void operator()(const RawAddress* bda, const BD_NAME bdn, uint16_t evt_len,
-                  tHCI_STATUS hci_status) {
-    body(bda, bdn, evt_len, hci_status);
-  }
-};
-extern struct btm_process_remote_name btm_process_remote_name;
-
 // Name: btm_set_eir_uuid
 // Params: const uint8_t* p_eir, tBTM_INQ_RESULTS* p_results
 // Return: void
diff --git a/system/test/mock/mock_stack_btm_interface.cc b/system/test/mock/mock_stack_btm_interface.cc
index 62094fa54c..0695ee2912 100644
--- a/system/test/mock/mock_stack_btm_interface.cc
+++ b/system/test/mock/mock_stack_btm_interface.cc
@@ -162,10 +162,6 @@ struct btm_client_interface_t default_btm_client_interface = {
                 .BTM_SecReadDevName = [](const RawAddress& /* bd_addr */) -> const char* {
                   return nullptr;
                 },
-                .BTM_SecAddRmtNameNotifyCallback =
-                        [](tBTM_RMT_NAME_CALLBACK* /* p_callback */) -> bool { return false; },
-                .BTM_SecDeleteRmtNameNotifyCallback =
-                        [](tBTM_RMT_NAME_CALLBACK* /* p_callback */) -> bool { return false; },
         },
         .ble = {
                 .BTM_BleGetEnergyInfo = [](tBTM_BLE_ENERGY_INFO_CBACK* /* p_ener_cback */)
diff --git a/system/test/mock/mock_stack_btm_sec.cc b/system/test/mock/mock_stack_btm_sec.cc
index 9d8c98c775..3971582d81 100644
--- a/system/test/mock/mock_stack_btm_sec.cc
+++ b/system/test/mock/mock_stack_btm_sec.cc
@@ -50,12 +50,10 @@ struct BTM_PasskeyReqReply BTM_PasskeyReqReply;
 struct BTM_PeerSupportsSecureConnections BTM_PeerSupportsSecureConnections;
 struct BTM_ReadLocalOobData BTM_ReadLocalOobData;
 struct BTM_RemoteOobDataReply BTM_RemoteOobDataReply;
-struct BTM_SecAddRmtNameNotifyCallback BTM_SecAddRmtNameNotifyCallback;
 struct BTM_SecBond BTM_SecBond;
 struct BTM_SecBondCancel BTM_SecBondCancel;
 struct BTM_SecClrService BTM_SecClrService;
 struct BTM_SecClrServiceByPsm BTM_SecClrServiceByPsm;
-struct BTM_SecDeleteRmtNameNotifyCallback BTM_SecDeleteRmtNameNotifyCallback;
 struct BTM_SecGetDeviceLinkKeyType BTM_SecGetDeviceLinkKeyType;
 struct BTM_SecIsSecurityPending BTM_SecIsSecurityPending;
 struct BTM_SecRegister BTM_SecRegister;
@@ -100,8 +98,6 @@ struct btm_sec_set_peer_sec_caps btm_sec_set_peer_sec_caps;
 struct btm_sec_update_clock_offset btm_sec_update_clock_offset;
 struct btm_simple_pair_complete btm_simple_pair_complete;
 
-struct BTM_IsRemoteNameKnown BTM_IsRemoteNameKnown;
-
 }  // namespace stack_btm_sec
 }  // namespace mock
 }  // namespace test
@@ -117,12 +113,10 @@ bool BTM_IsEncrypted::return_value = false;
 bool BTM_IsLinkKeyAuthed::return_value = false;
 bool BTM_IsLinkKeyKnown::return_value = false;
 bool BTM_PeerSupportsSecureConnections::return_value = false;
-bool BTM_SecAddRmtNameNotifyCallback::return_value = false;
 tBTM_STATUS BTM_SecBond::return_value = tBTM_STATUS::BTM_SUCCESS;
 tBTM_STATUS BTM_SecBondCancel::return_value = tBTM_STATUS::BTM_SUCCESS;
 uint8_t BTM_SecClrService::return_value = 0;
 uint8_t BTM_SecClrServiceByPsm::return_value = 0;
-bool BTM_SecDeleteRmtNameNotifyCallback::return_value = false;
 tBTM_LINK_KEY_TYPE BTM_SecGetDeviceLinkKeyType::return_value = 0;
 bool BTM_SecIsSecurityPending::return_value = false;
 bool BTM_SecRegister::return_value = false;
@@ -136,8 +130,6 @@ tBTM_STATUS btm_sec_l2cap_access_req::return_value = tBTM_STATUS::BTM_SUCCESS;
 tBTM_STATUS btm_sec_l2cap_access_req_by_requirement::return_value = tBTM_STATUS::BTM_SUCCESS;
 tBTM_STATUS btm_sec_mx_access_request::return_value = tBTM_STATUS::BTM_SUCCESS;
 
-bool BTM_IsRemoteNameKnown::return_value = false;
-
 }  // namespace stack_btm_sec
 }  // namespace mock
 }  // namespace test
@@ -188,10 +180,6 @@ void BTM_RemoteOobDataReply(tBTM_STATUS res, const RawAddress& bd_addr, const Oc
   inc_func_call_count(__func__);
   test::mock::stack_btm_sec::BTM_RemoteOobDataReply(res, bd_addr, c, r);
 }
-bool BTM_SecAddRmtNameNotifyCallback(tBTM_RMT_NAME_CALLBACK* p_callback) {
-  inc_func_call_count(__func__);
-  return test::mock::stack_btm_sec::BTM_SecAddRmtNameNotifyCallback(p_callback);
-}
 tBTM_STATUS BTM_SecBond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
                         tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
   inc_func_call_count(__func__);
@@ -209,10 +197,6 @@ uint8_t BTM_SecClrServiceByPsm(uint16_t psm) {
   inc_func_call_count(__func__);
   return test::mock::stack_btm_sec::BTM_SecClrServiceByPsm(psm);
 }
-bool BTM_SecDeleteRmtNameNotifyCallback(tBTM_RMT_NAME_CALLBACK* p_callback) {
-  inc_func_call_count(__func__);
-  return test::mock::stack_btm_sec::BTM_SecDeleteRmtNameNotifyCallback(p_callback);
-}
 tBTM_LINK_KEY_TYPE BTM_SecGetDeviceLinkKeyType(const RawAddress& bd_addr) {
   inc_func_call_count(__func__);
   return test::mock::stack_btm_sec::BTM_SecGetDeviceLinkKeyType(bd_addr);
@@ -411,10 +395,6 @@ void btm_simple_pair_complete(const RawAddress bd_addr, uint8_t status) {
   inc_func_call_count(__func__);
   test::mock::stack_btm_sec::btm_simple_pair_complete(bd_addr, status);
 }
-bool BTM_IsRemoteNameKnown(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
-  inc_func_call_count(__func__);
-  return test::mock::stack_btm_sec::BTM_IsRemoteNameKnown(bd_addr, transport);
-}
 bool BTM_BleIsLinkKeyKnown(const RawAddress /* address */) {
   inc_func_call_count(__func__);
   return false;
diff --git a/system/test/mock/mock_stack_btm_sec.h b/system/test/mock/mock_stack_btm_sec.h
index 43bed59177..7cb1354929 100644
--- a/system/test/mock/mock_stack_btm_sec.h
+++ b/system/test/mock/mock_stack_btm_sec.h
@@ -185,17 +185,6 @@ struct BTM_RemoteOobDataReply {
 };
 extern struct BTM_RemoteOobDataReply BTM_RemoteOobDataReply;
 
-// Name: BTM_SecAddRmtNameNotifyCallback
-// Params: tBTM_RMT_NAME_CALLBACK* p_callback
-// Return: bool
-struct BTM_SecAddRmtNameNotifyCallback {
-  static bool return_value;
-  std::function<bool(tBTM_RMT_NAME_CALLBACK* p_callback)> body{
-          [](tBTM_RMT_NAME_CALLBACK* /* p_callback */) { return return_value; }};
-  bool operator()(tBTM_RMT_NAME_CALLBACK* p_callback) { return body(p_callback); }
-};
-extern struct BTM_SecAddRmtNameNotifyCallback BTM_SecAddRmtNameNotifyCallback;
-
 // Name: BTM_SecBond
 // Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_TRANSPORT
 // transport, tBT_DEVICE_TYPE device_type, uint8_t pin_len, uint8_t* p_pin
@@ -246,17 +235,6 @@ struct BTM_SecClrServiceByPsm {
 };
 extern struct BTM_SecClrServiceByPsm BTM_SecClrServiceByPsm;
 
-// Name: BTM_SecDeleteRmtNameNotifyCallback
-// Params: tBTM_RMT_NAME_CALLBACK* p_callback
-// Return: bool
-struct BTM_SecDeleteRmtNameNotifyCallback {
-  static bool return_value;
-  std::function<bool(tBTM_RMT_NAME_CALLBACK* p_callback)> body{
-          [](tBTM_RMT_NAME_CALLBACK* /* p_callback */) { return return_value; }};
-  bool operator()(tBTM_RMT_NAME_CALLBACK* p_callback) { return body(p_callback); }
-};
-extern struct BTM_SecDeleteRmtNameNotifyCallback BTM_SecDeleteRmtNameNotifyCallback;
-
 // Name: BTM_SecGetDeviceLinkKeyType
 // Params: const RawAddress& bd_addr
 // Return: tBTM_LINK_KEY_TYPE
diff --git a/system/test/mock/mock_stack_security_client_interface.h b/system/test/mock/mock_stack_security_client_interface.h
index 875a1b5a25..94432139d7 100644
--- a/system/test/mock/mock_stack_security_client_interface.h
+++ b/system/test/mock/mock_stack_security_client_interface.h
@@ -71,9 +71,6 @@ struct MockSecurityClientInterface : public SecurityClientInterface {
               (const RawAddress& /* bd_addr */, uint8_t /* res */, uint32_t /* passkey */));
   MOCK_METHOD((uint8_t), BTM_GetSecurityMode, ());
   MOCK_METHOD((const char*), BTM_SecReadDevName, (const RawAddress& /* bd_addr */));
-  MOCK_METHOD((bool), BTM_SecAddRmtNameNotifyCallback, (tBTM_RMT_NAME_CALLBACK* /* p_callback */));
-  MOCK_METHOD((bool), BTM_SecDeleteRmtNameNotifyCallback,
-              (tBTM_RMT_NAME_CALLBACK* /* p_callback */));
 };
 
 // Initialize the working btm client interface to the default