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

Commit 061242e3 authored by Henri Chataing's avatar Henri Chataing
Browse files

system: Enforce -Wunused-parameter 

Bug: 299772495
Test: m com.android.btservices
Flag: EXEMPT, mechanical refactor
Change-Id: Ifa12df68191725545adaad8eb0c6ada5dfd28d2d
parent bf1b33b3

system/gd/dumpsys/bundler/Android.bp

+0 −2
Original line number Diff line number Diff line
@@ -72,7 +72,6 @@ cc_binary_host { 
    defaults: [

        "bluetooth_flatbuffer_bundler_defaults",

    ],

    cflags: ["-Wno-unused-parameter"],

}



cc_test_host {
@@ -89,5 +88,4 @@ cc_test_host { 
    test_options: {

        unit_test: true,

    },

    cflags: ["-Wno-unused-parameter"],

}

system/gd/dumpsys/bundler/bundler.cc

+1 −1
Original line number Diff line number Diff line
@@ -261,7 +261,7 @@ int WriteBundledSchema() { 
  return EXIT_SUCCESS;

}



int Usage(int argc, char** argv) {

int Usage(int /*argc*/, char** argv) {

  fprintf(stderr,

          "Usage: %s [-r | -w] [-f <filename>] [-g <gen_out_path>] [-n <namespace> ] [-v] -m "

          "<main_root_name> <file.bfbs "

system/main/Android.bp

+0 −7
Original line number Diff line number Diff line
@@ -58,7 +58,6 @@ cc_library_static { 
        "libcom.android.sysprop.bluetooth.wrapped",

    ],

    header_libs: ["libbluetooth_headers"],

    cflags: ["-Wno-unused-parameter"],

}



cc_library {
@@ -135,11 +134,6 @@ cc_library_static { 
        "BluetoothGeneratedBundlerSchema_h_bfbs",

        "BluetoothGeneratedDumpsysDataSchema_h",

    ],

    cflags: [

        "-Wno-unused-parameter",

    ],

    shared_libs: [

    ],

    whole_static_libs: [

        "libbluetooth_gd", // Gabeldorsche

    ],
@@ -246,7 +240,6 @@ cc_test { 
    ],

    min_sdk_version: "Tiramisu",

    header_libs: ["libbluetooth_headers"],

    cflags: ["-Wno-unused-parameter"],

}



cc_test {

system/main/test/main_shim_stack_lifecycle_test.cc

+16 −16
Original line number Diff line number Diff line
@@ -157,7 +157,7 @@ public: 
  }



protected:

  void ListDependencies(ModuleList* list) const override {}

  void ListDependencies(ModuleList* /*list*/) const override {}

  void Start() override { log::error("Started TestStackModuleBase"); }

  void Stop() override { log::error("Stopped TestStackModuleBase"); }

  std::string ToString() const override { return std::string("TestFunction"); }
@@ -503,29 +503,29 @@ TEST_F(StackLifecycleWithDefaultModulesUnitTest, client_using_stack_manager) { 
  for (int i = 0; i < kNumIters; i++) {

    for (auto& c : client_group.clients_) {

      c->Post(base::BindOnce(

              [](int id, int iter, std::shared_ptr<TestStackManager> stack_manager) {

              [](int /*id*/, int iter, std::shared_ptr<TestStackManager> stack_manager) {

                stack_manager->GetUnsafeModule<TestStackModule1>()->TestMethod({

                        .iter = iter,

                        .tag = std::string(kTestDataTag),

                        .callback = [](TestCallbackData data) {},

                        .callback = [](TestCallbackData /*data*/) {},

                });

              },

              c->Id(), i, StackManager()));

      c->Post(base::BindOnce(

              [](int id, int iter, std::shared_ptr<TestStackManager> stack_manager) {

              [](int /*id*/, int iter, std::shared_ptr<TestStackManager> stack_manager) {

                stack_manager->GetUnsafeModule<TestStackModule2>()->TestMethod({

                        .iter = iter,

                        .tag = std::string(kTestDataTag),

                        .callback = [](TestCallbackData data) {},

                        .callback = [](TestCallbackData /*data*/) {},

                });

              },

              c->Id(), i, StackManager()));

      c->Post(base::BindOnce(

              [](int id, int iter, std::shared_ptr<TestStackManager> stack_manager) {

              [](int /*id*/, int iter, std::shared_ptr<TestStackManager> stack_manager) {

                stack_manager->GetUnsafeModule<TestStackModule3>()->TestMethod({

                        .iter = iter,

                        .tag = std::string(kTestDataTag),

                        .callback = [](TestCallbackData data) {},

                        .callback = [](TestCallbackData /*data*/) {},

                });

              },

              c->Id(), i, StackManager()));
@@ -554,12 +554,12 @@ TEST_F(StackLifecycleWithDefaultModulesUnitTest, client_using_stack_manager_when 
  for (int i = 0; i < kNumIters; i++) {

    for (auto& c : client_group.clients_) {

      c->Post(base::BindOnce(

              [](int id, int iter, Counters* counters,

                 std::shared_ptr<TestStackManager> stack_manager) {

              [](int /*id*/, int iter, Counters* counters,

                 std::shared_ptr<TestStackManager> /*stack_manager*/) {

                TestData test_data = {

                        .iter = iter,

                        .tag = std::string(kTestDataTag),

                        .callback = [](TestCallbackData data) {},

                        .callback = [](TestCallbackData /*data*/) {},

                };

                if (bluetooth::shim::Stack::GetInstance()->CallOnModule<TestStackModule1>(

                            [test_data](TestStackModule1* mod) { mod->TestMethod(test_data); })) {
@@ -570,12 +570,12 @@ TEST_F(StackLifecycleWithDefaultModulesUnitTest, client_using_stack_manager_when 
              },

              c->Id(), i, &counters, StackManager()));

      c->Post(base::BindOnce(

              [](int id, int iter, Counters* counters,

                 std::shared_ptr<TestStackManager> stack_manager) {

              [](int /*id*/, int iter, Counters* counters,

                 std::shared_ptr<TestStackManager> /*stack_manager*/) {

                TestData test_data = {

                        .iter = iter,

                        .tag = std::string(kTestDataTag),

                        .callback = [](TestCallbackData data) {},

                        .callback = [](TestCallbackData /*data*/) {},

                };

                if (bluetooth::shim::Stack::GetInstance()->CallOnModule<TestStackModule2>(

                            [test_data](TestStackModule2* mod) { mod->TestMethod(test_data); })) {
@@ -586,12 +586,12 @@ TEST_F(StackLifecycleWithDefaultModulesUnitTest, client_using_stack_manager_when 
              },

              c->Id(), i, &counters, StackManager()));

      c->Post(base::BindOnce(

              [](int id, int iter, Counters* counters,

                 std::shared_ptr<TestStackManager> stack_manager) {

              [](int /*id*/, int iter, Counters* counters,

                 std::shared_ptr<TestStackManager> /*stack_manager*/) {

                TestData test_data = {

                        .iter = iter,

                        .tag = std::string(kTestDataTag),

                        .callback = [](TestCallbackData data) {},

                        .callback = [](TestCallbackData /*data*/) {},

                };

                if (bluetooth::shim::Stack::GetInstance()->CallOnModule<TestStackModule3>(

                            [test_data](TestStackModule3* mod) { mod->TestMethod(test_data); })) {

system/main/test/main_shim_test.cc

+48 −42
Original line number Diff line number Diff line
@@ -123,36 +123,39 @@ bluetooth::common::TimestamperInMilliseconds timestamper_in_milliseconds; 


void mock_on_send_data_upwards(BT_HDR*) {}



void mock_on_packets_completed(uint16_t handle, uint16_t num_packets) {}

void mock_on_packets_completed(uint16_t /*handle*/, uint16_t /*num_packets*/) {}



void mock_connection_classic_on_connected(const RawAddress& bda, uint16_t handle, uint8_t enc_mode,

                                          bool locally_initiated) {}

void mock_connection_classic_on_connected(const RawAddress& /*bda*/, uint16_t /*handle*/,

                                          uint8_t /*enc_mode*/, bool /*locally_initiated*/) {}



void mock_connection_classic_on_failed(const RawAddress& bda, tHCI_STATUS status,

                                       bool locally_initiated) {}

void mock_connection_classic_on_failed(const RawAddress& /*bda*/, tHCI_STATUS /*status*/,

                                       bool /*locally_initiated*/) {}



void mock_connection_classic_on_disconnected(tHCI_STATUS status, uint16_t handle,

                                             tHCI_STATUS reason) {

void mock_connection_classic_on_disconnected(tHCI_STATUS /*status*/, uint16_t handle,

                                             tHCI_STATUS /*reason*/) {

  ASSERT_TRUE(mock_function_handle_promise_map.find(__func__) !=

              mock_function_handle_promise_map.end());

  mock_function_handle_promise_map[__func__].set_value(handle);

}

void mock_connection_le_on_connected(const tBLE_BD_ADDR& address_with_type, uint16_t handle,

                                     tHCI_ROLE role, uint16_t conn_interval, uint16_t conn_latency,

                                     uint16_t conn_timeout, const RawAddress& local_rpa,

                                     const RawAddress& peer_rpa, tBLE_ADDR_TYPE peer_addr_type,

                                     bool can_read_discoverable_characteristics) {}

void mock_connection_le_on_failed(const tBLE_BD_ADDR& address_with_type, uint16_t handle,

                                  bool enhanced, tHCI_STATUS status) {}

void mock_connection_le_on_connected(const tBLE_BD_ADDR& /*address_with_type*/, uint16_t /*handle*/,

                                     tHCI_ROLE /*role*/, uint16_t /*conn_interval*/,

                                     uint16_t /*conn_latency*/, uint16_t /*conn_timeout*/,

                                     const RawAddress& /*local_rpa*/,

                                     const RawAddress& /*peer_rpa*/,

                                     tBLE_ADDR_TYPE /*peer_addr_type*/,

                                     bool /*can_read_discoverable_characteristics*/) {}

void mock_connection_le_on_failed(const tBLE_BD_ADDR& /*address_with_type*/, uint16_t /*handle*/,

                                  bool /*enhanced*/, tHCI_STATUS /*status*/) {}

static std::promise<uint16_t> mock_connection_le_on_disconnected_promise;

void mock_connection_le_on_disconnected(tHCI_STATUS status, uint16_t handle, tHCI_STATUS reason) {

void mock_connection_le_on_disconnected(tHCI_STATUS /*status*/, uint16_t handle,

                                        tHCI_STATUS /*reason*/) {

  mock_connection_le_on_disconnected_promise.set_value(handle);

}



void mock_link_classic_on_read_remote_extended_features_complete(uint16_t handle,

                                                                 uint8_t current_page_number,

                                                                 uint8_t max_page_number,

                                                                 uint64_t features) {}

void mock_link_classic_on_read_remote_extended_features_complete(uint16_t /*handle*/,

                                                                 uint8_t /*current_page_number*/,

                                                                 uint8_t /*max_page_number*/,

                                                                 uint64_t /*features*/) {}



shim::acl_interface_t acl_interface{

        .on_send_data_upwards = mock_on_send_data_upwards,
@@ -211,7 +214,7 @@ template <typename T> 
class MockEnQueue : public os::IQueueEnqueue<T> {

  using EnqueueCallback = base::Callback<std::unique_ptr<T>()>;



  void RegisterEnqueue(os::Handler* handler, EnqueueCallback callback) override {}

  void RegisterEnqueue(os::Handler* /*handler*/, EnqueueCallback /*callback*/) override {}

  void UnregisterEnqueue() override {}

};
@@ -219,7 +222,7 @@ template <typename T> 
class MockDeQueue : public os::IQueueDequeue<T> {

  using DequeueCallback = base::Callback<void()>;



  void RegisterDequeue(os::Handler* handler, DequeueCallback callback) override {}

  void RegisterDequeue(os::Handler* /*handler*/, DequeueCallback /*callback*/) override {}

  void UnregisterDequeue() override {}

  std::unique_ptr<T> TryDequeue() override { return nullptr; }

};
@@ -258,7 +261,7 @@ public: 
    return true;

  }



  bool Disconnect(hci::DisconnectReason reason) override {

  bool Disconnect(hci::DisconnectReason /*reason*/) override {

    disconnect_cnt_++;

    disconnect_promise_.set_value(handle_);

    return true;
@@ -299,7 +302,7 @@ public: 
  bool ReadRemoteVersionInformation() override { return true; }

  bool LeReadRemoteFeatures() override { return true; }



  void Disconnect(hci::DisconnectReason reason) override {

  void Disconnect(hci::DisconnectReason /*reason*/) override {

    disconnect_cnt_++;

    disconnect_promise_.set_value(handle_);

  }
@@ -546,24 +549,27 @@ TEST_F(MainShimTest, BleScannerInterfaceImpl_nop) { 
class TestScanningCallbacks : public ::ScanningCallbacks {

public:

  ~TestScanningCallbacks() {}

  void OnScannerRegistered(const bluetooth::Uuid app_uuid, uint8_t scannerId,

                           uint8_t status) override {}

  void OnSetScannerParameterComplete(uint8_t scannerId, uint8_t status) override {}

  void OnScanResult(uint16_t event_type, uint8_t addr_type, RawAddress bda, uint8_t primary_phy,

                    uint8_t secondary_phy, uint8_t advertising_sid, int8_t tx_power, int8_t rssi,

                    uint16_t periodic_adv_int, std::vector<uint8_t> adv_data) override {}

  void OnTrackAdvFoundLost(AdvertisingTrackInfo advertising_track_info) override {}

  void OnBatchScanReports(int client_if, int status, int report_format, int num_records,

                          std::vector<uint8_t> data) override {}

  void OnBatchScanThresholdCrossed(int client_if) override {}

  void OnPeriodicSyncStarted(int reg_id, uint8_t status, uint16_t sync_handle,

                             uint8_t advertising_sid, uint8_t address_type, RawAddress address,

                             uint8_t phy, uint16_t interval) override {}

  void OnPeriodicSyncReport(uint16_t sync_handle, int8_t tx_power, int8_t rssi, uint8_t status,

                            std::vector<uint8_t> data) override {}

  void OnPeriodicSyncLost(uint16_t sync_handle) override {}

  void OnPeriodicSyncTransferred(int pa_source, uint8_t status, RawAddress address) override {}

  void OnBigInfoReport(uint16_t sync_handle, bool encrypted) override {}

  void OnScannerRegistered(const bluetooth::Uuid /*app_uuid*/, uint8_t /*scannerId*/,

                           uint8_t /*status*/) override {}

  void OnSetScannerParameterComplete(uint8_t /*scannerId*/, uint8_t /*status*/) override {}

  void OnScanResult(uint16_t /*event_type*/, uint8_t /*addr_type*/, RawAddress /*bda*/,

                    uint8_t /*primary_phy*/, uint8_t /*secondary_phy*/, uint8_t /*advertising_sid*/,

                    int8_t /*tx_power*/, int8_t /*rssi*/, uint16_t /*periodic_adv_int*/,

                    std::vector<uint8_t> /*adv_data*/) override {}

  void OnTrackAdvFoundLost(AdvertisingTrackInfo /*advertising_track_info*/) override {}

  void OnBatchScanReports(int /*client_if*/, int /*status*/, int /*report_format*/,

                          int /*num_records*/, std::vector<uint8_t> /*data*/) override {}

  void OnBatchScanThresholdCrossed(int /*client_if*/) override {}

  void OnPeriodicSyncStarted(int /*reg_id*/, uint8_t /*status*/, uint16_t /*sync_handle*/,

                             uint8_t /*advertising_sid*/, uint8_t /*address_type*/,

                             RawAddress /*address*/, uint8_t /*phy*/,

                             uint16_t /*interval*/) override {}

  void OnPeriodicSyncReport(uint16_t /*sync_handle*/, int8_t /*tx_power*/, int8_t /*rssi*/,

                            uint8_t /*status*/, std::vector<uint8_t> /*data*/) override {}

  void OnPeriodicSyncLost(uint16_t /*sync_handle*/) override {}

  void OnPeriodicSyncTransferred(int /*pa_source*/, uint8_t /*status*/,

                                 RawAddress /*address*/) override {}

  void OnBigInfoReport(uint16_t /*sync_handle*/, bool /*encrypted*/) override {}

};



TEST_F(MainShimTest, DISABLED_BleScannerInterfaceImpl_OnScanResult) {
@@ -646,7 +652,7 @@ TEST_F(MainShimTestWithClassicConnection, nop) {} 
TEST_F(MainShimTestWithClassicConnection, read_extended_feature) {

  int read_remote_extended_feature_call_count = 0;

  raw_connection_->read_remote_extended_features_function_ =

          [&read_remote_extended_feature_call_count](uint8_t page_number) {

          [&read_remote_extended_feature_call_count](uint8_t /*page_number*/) {

            read_remote_extended_feature_call_count++;

          };