Enum-ify stack::sdp::tSDP_FLAGS,tSDP_DISC_WAIT,tSDP_STATE

Bug: 259118978
Test: net_test_stack_sdp

Change-Id: I3c9da3800acda3e521fd80e5b858b4ef396df847

system/bta/include/bta_api.h

@@ -79,8 +79,6 @@ inline std::string bta_status_text(const tBTA_STATUS& status) {
 
 #undef CASE_RETURN_TEXT
 
-using tSDP_DISC_WAIT = int;
-
 /*
  * Service ID
  */

system/stack/sdp/sdpint.h

@@ -124,18 +124,65 @@ typedef struct {
                            attributes in the responses */
 } tSDP_CONT_INFO;
 
+enum : uint8_t {
+  SDP_STATE_IDLE = 0,
+  SDP_STATE_CONN_SETUP = 1,
+  SDP_STATE_CFG_SETUP = 2,
+  SDP_STATE_CONNECTED = 3,
+  SDP_STATE_CONN_PEND = 4,
+};
+typedef uint8_t tSDP_STATE;
+
+#ifndef CASE_RETURN_TEXT
+#define CASE_RETURN_TEXT(code) \
+  case code:                   \
+    return #code
+#endif
+
+inline std::string sdp_state_text(const tSDP_STATE& state) {
+  switch (state) {
+    CASE_RETURN_TEXT(SDP_STATE_IDLE);
+    CASE_RETURN_TEXT(SDP_STATE_CONN_SETUP);
+    CASE_RETURN_TEXT(SDP_STATE_CFG_SETUP);
+    CASE_RETURN_TEXT(SDP_STATE_CONNECTED);
+    CASE_RETURN_TEXT(SDP_STATE_CONN_PEND);
+    default:
+      return std::string("UNKNOWN[") + std::to_string(state) + std::string("]");
+  }
+}
+
+enum : uint8_t {
+  SDP_FLAGS_IS_ORIG = 0x01,
+  SDP_FLAGS_HIS_CFG_DONE = 0x02,
+  SDP_FLAGS_MY_CFG_DONE = 0x04,
+};
+typedef uint8_t tSDP_FLAGS;
+
+inline std::string sdp_flags_text(const tSDP_FLAGS& flags) {
+  switch (flags) {
+    CASE_RETURN_TEXT(SDP_FLAGS_IS_ORIG);
+    CASE_RETURN_TEXT(SDP_FLAGS_HIS_CFG_DONE);
+    CASE_RETURN_TEXT(SDP_FLAGS_MY_CFG_DONE);
+    default:
+      return std::string("UNKNOWN[") + std::to_string(flags) + std::string("]");
+  }
+}
+
+#undef CASE_RETURN_TEXT
+
+enum : uint8_t {
+  SDP_DISC_WAIT_CONN = 0,
+  SDP_DISC_WAIT_HANDLES = 1,
+  SDP_DISC_WAIT_ATTR = 2,
+  SDP_DISC_WAIT_SEARCH_ATTR = 3,
+  SDP_DISC_WAIT_UNUSED4 = 4,
+  SDP_DISC_WAIT_CANCEL = 5,
+};
+typedef uint8_t tSDP_DISC_WAIT;
+
 /* Define the SDP Connection Control Block */
 struct tCONN_CB {
-#define SDP_STATE_IDLE 0
-#define SDP_STATE_CONN_SETUP 1
-#define SDP_STATE_CFG_SETUP 2
-#define SDP_STATE_CONNECTED 3
-#define SDP_STATE_CONN_PEND 4
   uint8_t con_state;
-
-#define SDP_FLAGS_IS_ORIG 0x01
-#define SDP_FLAGS_HIS_CFG_DONE 0x02
-#define SDP_FLAGS_MY_CFG_DONE 0x04
   uint8_t con_flags;
 
   RawAddress device_address;
@@ -159,12 +206,6 @@ struct tCONN_CB {
   uint16_t transaction_id;
   uint16_t disconnect_reason; /* Disconnect reason            */
 
-#define SDP_DISC_WAIT_CONN 0
-#define SDP_DISC_WAIT_HANDLES 1
-#define SDP_DISC_WAIT_ATTR 2
-#define SDP_DISC_WAIT_SEARCH_ATTR 3
-#define SDP_DISC_WAIT_CANCEL 5
-
   uint8_t disc_state;
   bool is_attr_search;
 
@@ -183,9 +224,7 @@ struct tCONN_CB {
     return #code
 #endif
 
-using tSDP_DISC_WAIT = int;
-
-inline std::string discovery_state_text(const tSDP_DISC_WAIT& state) {
+inline std::string sdp_disc_wait_text(const tSDP_DISC_WAIT& state) {
   switch (state) {
     CASE_RETURN_TEXT(SDP_DISC_WAIT_CONN);
     CASE_RETURN_TEXT(SDP_DISC_WAIT_HANDLES);

system/stack/test/sdp/stack_sdp_test.cc

@@ -173,7 +173,7 @@ TEST_F(StackSdpMainTest, sdp_service_search_request_queuing_race_condition) {
   sdp_disconnect(p_ccb2, SDP_SUCCESS);
 }
 
-TEST_F(StackSdpMainTest, discovery_state_text) {
+TEST_F(StackSdpMainTest, sdp_disc_wait_text) {
   std::vector<std::pair<tSDP_DISC_WAIT, std::string>> states = {
       std::make_pair(SDP_DISC_WAIT_CONN, "SDP_DISC_WAIT_CONN"),
       std::make_pair(SDP_DISC_WAIT_HANDLES, "SDP_DISC_WAIT_HANDLES"),
@@ -182,13 +182,48 @@ TEST_F(StackSdpMainTest, discovery_state_text) {
       std::make_pair(SDP_DISC_WAIT_CANCEL, "SDP_DISC_WAIT_CANCEL"),
   };
   for (const auto& state : states) {
-    ASSERT_STREQ(state.second.c_str(),
-                 discovery_state_text(state.first).c_str());
+    ASSERT_STREQ(state.second.c_str(), sdp_disc_wait_text(state.first).c_str());
   }
   auto unknown =
-      base::StringPrintf("UNKNOWN[%d]", std::numeric_limits<int>::max());
+      base::StringPrintf("UNKNOWN[%d]", std::numeric_limits<uint8_t>::max());
   ASSERT_STREQ(unknown.c_str(),
-               discovery_state_text(
-                   static_cast<tSDP_DISC_WAIT>(std::numeric_limits<int>::max()))
+               sdp_disc_wait_text(static_cast<tSDP_DISC_WAIT>(
+                                      std::numeric_limits<uint8_t>::max()))
+                   .c_str());
+}
+
+TEST_F(StackSdpMainTest, sdp_state_text) {
+  std::vector<std::pair<tSDP_STATE, std::string>> states = {
+      std::make_pair(SDP_STATE_IDLE, "SDP_STATE_IDLE"),
+      std::make_pair(SDP_STATE_CONN_SETUP, "SDP_STATE_CONN_SETUP"),
+      std::make_pair(SDP_STATE_CFG_SETUP, "SDP_STATE_CFG_SETUP"),
+      std::make_pair(SDP_STATE_CONNECTED, "SDP_STATE_CONNECTED"),
+      std::make_pair(SDP_STATE_CONN_PEND, "SDP_STATE_CONN_PEND"),
+  };
+  for (const auto& state : states) {
+    ASSERT_STREQ(state.second.c_str(), sdp_state_text(state.first).c_str());
+  }
+  auto unknown = base::StringPrintf("UNKNOWN[%hhu]",
+                                    std::numeric_limits<std::uint8_t>::max());
+  ASSERT_STREQ(unknown.c_str(),
+               sdp_state_text(static_cast<tSDP_STATE>(
+                                  std::numeric_limits<std::uint8_t>::max()))
+                   .c_str());
+}
+
+TEST_F(StackSdpMainTest, sdp_flags_text) {
+  std::vector<std::pair<tSDP_DISC_WAIT, std::string>> flags = {
+      std::make_pair(SDP_FLAGS_IS_ORIG, "SDP_FLAGS_IS_ORIG"),
+      std::make_pair(SDP_FLAGS_HIS_CFG_DONE, "SDP_FLAGS_HIS_CFG_DONE"),
+      std::make_pair(SDP_FLAGS_MY_CFG_DONE, "SDP_FLAGS_MY_CFG_DONE"),
+  };
+  for (const auto& flag : flags) {
+    ASSERT_STREQ(flag.second.c_str(), sdp_flags_text(flag.first).c_str());
+  }
+  auto unknown =
+      base::StringPrintf("UNKNOWN[%hhu]", std::numeric_limits<uint8_t>::max());
+  ASSERT_STREQ(unknown.c_str(),
+               sdp_flags_text(static_cast<tSDP_DISC_WAIT>(
+                                  std::numeric_limits<uint8_t>::max()))
                    .c_str());
 }