| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/time/time.h" |
| #include "chromeos/ash/components/audio/audio_device_selection_test_base.h" |
| |
| #include "ash/constants/ash_features.h" |
| #include "base/test/metrics/user_action_tester.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "chromeos/ash/components/audio/audio_device_encoding.h" |
| #include "chromeos/ash/components/audio/audio_device_metrics_handler.h" |
| #include "chromeos/ash/components/audio/cras_audio_handler.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace ash { |
| |
| namespace { |
| |
| // The bucket sample constant for testing the system switch or not switch |
| // decision after audio device has changed. |
| constexpr uint8_t kSystemNotSwitchSample = 0; |
| constexpr uint8_t kSystemSwitchSample = 1; |
| |
| // Test the histogram of system switch or not switch decision after audio device |
| // has changed. |
| void ExpectSystemDecisionHistogramCount( |
| const base::HistogramTester& histogram_tester, |
| uint16_t expected_system_switch_input_count, |
| uint16_t expected_system_not_switch_input_count, |
| uint16_t expected_system_switch_output_count, |
| uint16_t expected_system_not_switch_output_count, |
| bool is_chrome_restarts) { |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudio, kSystemSwitchSample, |
| expected_system_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudio, |
| kSystemNotSwitchSample, expected_system_not_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudio, kSystemSwitchSample, |
| expected_system_switch_output_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudio, |
| kSystemNotSwitchSample, expected_system_not_switch_output_count); |
| |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents::kSystemSwitchInput, |
| expected_system_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents::kSystemNotSwitchInput, |
| expected_system_not_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents::kSystemSwitchOutput, |
| expected_system_switch_output_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents::kSystemNotSwitchOutput, |
| expected_system_not_switch_output_count); |
| |
| if (is_chrome_restarts) { |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioChromeRestarts, |
| kSystemSwitchSample, expected_system_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioChromeRestarts, |
| kSystemNotSwitchSample, expected_system_not_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioChromeRestarts, |
| kSystemSwitchSample, expected_system_switch_output_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioChromeRestarts, |
| kSystemNotSwitchSample, expected_system_not_switch_output_count); |
| |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemSwitchInputChromeRestart, |
| expected_system_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemNotSwitchInputChromeRestart, |
| expected_system_not_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemSwitchOutputChromeRestart, |
| expected_system_switch_output_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemNotSwitchOutputChromeRestart, |
| expected_system_not_switch_output_count); |
| } else { |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioNonChromeRestarts, |
| kSystemSwitchSample, expected_system_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioNonChromeRestarts, |
| kSystemNotSwitchSample, expected_system_not_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioNonChromeRestarts, |
| kSystemSwitchSample, expected_system_switch_output_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioNonChromeRestarts, |
| kSystemNotSwitchSample, expected_system_not_switch_output_count); |
| |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemSwitchInputNonChromeRestart, |
| expected_system_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemNotSwitchInputNonChromeRestart, |
| expected_system_not_switch_input_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemSwitchOutputNonChromeRestart, |
| expected_system_switch_output_count); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kSystemNotSwitchOutputNonChromeRestart, |
| expected_system_not_switch_output_count); |
| } |
| } |
| |
| // Test the histogram of user override after system switch or not switch. |
| void ExpectUserOverrideSystemDecisionHistogramCount( |
| const base::HistogramTester& histogram_tester, |
| uint16_t expected_user_override_system_switch_input_count, |
| uint16_t expected_user_override_system_not_switch_input_count, |
| uint16_t expected_user_override_system_switch_output_count, |
| uint16_t expected_user_override_system_not_switch_output_count, |
| bool is_chrome_restarts) { |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kUserOverrideSystemSwitchInputAudio, |
| expected_user_override_system_switch_input_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kUserOverrideSystemNotSwitchInputAudio, |
| expected_user_override_system_not_switch_input_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kUserOverrideSystemSwitchOutputAudio, |
| expected_user_override_system_switch_output_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kUserOverrideSystemNotSwitchOutputAudio, |
| expected_user_override_system_not_switch_output_count); |
| |
| if (is_chrome_restarts) { |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchInputAudioChromeRestarts, |
| expected_user_override_system_switch_input_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchInputAudioChromeRestarts, |
| expected_user_override_system_not_switch_input_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchOutputAudioChromeRestarts, |
| expected_user_override_system_switch_output_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchOutputAudioChromeRestarts, |
| expected_user_override_system_not_switch_output_count); |
| } else { |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchInputAudioNonChromeRestarts, |
| expected_user_override_system_switch_input_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchInputAudioNonChromeRestarts, |
| expected_user_override_system_not_switch_input_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchOutputAudioNonChromeRestarts, |
| expected_user_override_system_switch_output_count); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchOutputAudioNonChromeRestarts, |
| expected_user_override_system_not_switch_output_count); |
| } |
| } |
| |
| // Test the histogram of user override after system switch or not switch, these |
| // metrics are only fired within limited time frame. |
| void ExpectUserOverrideSystemDecisionHistogramCountInLimitedTime( |
| const base::HistogramTester& histogram_tester, |
| uint16_t expected_user_override_system_switch_input_count_in_limited_time, |
| uint16_t |
| expected_user_override_system_not_switch_input_count_in_limited_time, |
| uint16_t expected_user_override_system_switch_output_count_in_limited_time, |
| uint16_t |
| expected_user_override_system_not_switch_output_count_in_limited_time, |
| bool is_chrome_restarts) { |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemSwitchInput, |
| expected_user_override_system_switch_input_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemNotSwitchInput, |
| expected_user_override_system_not_switch_input_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemSwitchOutput, |
| expected_user_override_system_switch_output_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemNotSwitchOutput, |
| expected_user_override_system_not_switch_output_count_in_limited_time); |
| |
| if (is_chrome_restarts) { |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemSwitchInputChromeRestart, |
| expected_user_override_system_switch_input_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemNotSwitchInputChromeRestart, |
| expected_user_override_system_not_switch_input_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemSwitchOutputChromeRestart, |
| expected_user_override_system_switch_output_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemNotSwitchOutputChromeRestart, |
| expected_user_override_system_not_switch_output_count_in_limited_time); |
| } else { |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemSwitchInputNonChromeRestart, |
| expected_user_override_system_switch_input_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemNotSwitchInputNonChromeRestart, |
| expected_user_override_system_not_switch_input_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemSwitchOutputNonChromeRestart, |
| expected_user_override_system_switch_output_count_in_limited_time); |
| histogram_tester.ExpectBucketCount( |
| AudioDeviceMetricsHandler::kAudioSelectionPerformance, |
| AudioDeviceMetricsHandler::AudioSelectionEvents:: |
| kUserOverrideSystemNotSwitchOutputNonChromeRestart, |
| expected_user_override_system_not_switch_output_count_in_limited_time); |
| } |
| } |
| |
| // Test the time delta histogram of user override after system switch or not |
| // switch. |
| void ExpectUserOverrideSystemDecisionTimeDelta( |
| const base::HistogramTester& histogram_tester, |
| bool is_input, |
| bool system_has_switched, |
| uint16_t delta_in_minute, |
| bool is_chrome_restarts) { |
| std::string histogram_name; |
| if (is_input) { |
| histogram_name = |
| system_has_switched |
| ? AudioDeviceMetricsHandler::kUserOverrideSystemSwitchInputAudio |
| : AudioDeviceMetricsHandler::kUserOverrideSystemNotSwitchInputAudio; |
| } else { |
| histogram_name = |
| system_has_switched |
| ? AudioDeviceMetricsHandler::kUserOverrideSystemSwitchOutputAudio |
| : AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchOutputAudio; |
| } |
| |
| histogram_tester.ExpectTimeBucketCount( |
| histogram_name, |
| base::Minutes(delta_in_minute) / base::Minutes(1).InMilliseconds(), |
| /*expected_count=*/1); |
| |
| std::string histogram_name_separated_by_chrome_restarts; |
| |
| if (is_chrome_restarts) { |
| if (is_input) { |
| histogram_name_separated_by_chrome_restarts = |
| system_has_switched |
| ? AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchInputAudioChromeRestarts |
| : AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchInputAudioChromeRestarts; |
| } else { |
| histogram_name_separated_by_chrome_restarts = |
| system_has_switched |
| ? AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchOutputAudioChromeRestarts |
| : AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchOutputAudioChromeRestarts; |
| } |
| } else { |
| if (is_input) { |
| histogram_name_separated_by_chrome_restarts = |
| system_has_switched |
| ? AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchInputAudioNonChromeRestarts |
| : AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchInputAudioNonChromeRestarts; |
| } else { |
| histogram_name_separated_by_chrome_restarts = |
| system_has_switched |
| ? AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchOutputAudioNonChromeRestarts |
| : AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchOutputAudioNonChromeRestarts; |
| } |
| } |
| |
| histogram_tester.ExpectTimeBucketCount( |
| histogram_name_separated_by_chrome_restarts, |
| base::Minutes(delta_in_minute) / base::Minutes(1).InMilliseconds(), |
| /*expected_count=*/1); |
| } |
| |
| // Test the histogram of consecutive decives change. |
| void ExpectConsecutiveDeviceChangeHistogramCount( |
| const base::HistogramTester& histogram_tester, |
| uint16_t expected_consecutive_input_device_changed, |
| uint16_t expected_consecutive_output_device_changed, |
| uint16_t expected_consecutive_input_device_added, |
| uint16_t expected_consecutive_output_device_added) { |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kConsecutiveInputDevicsChanged, |
| expected_consecutive_input_device_changed); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kConsecutiveOutputDevicsChanged, |
| expected_consecutive_output_device_changed); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kConsecutiveInputDevicsAdded, |
| expected_consecutive_input_device_added); |
| histogram_tester.ExpectTotalCount( |
| AudioDeviceMetricsHandler::kConsecutiveOutputDevicsAdded, |
| expected_consecutive_output_device_added); |
| } |
| |
| class AudioDeviceSelectionTest : public AudioDeviceSelectionTestBase {}; |
| |
| TEST_F(AudioDeviceSelectionTest, PlugUnplugMetricAction) { |
| AudioNode input1 = NewInputNode("USB"); |
| AudioNode input2 = NewInputNode("USB"); |
| AudioNode output3 = NewOutputNode("USB"); |
| AudioNode output4 = NewOutputNode("USB"); |
| |
| { |
| base::UserActionTester actions; |
| Plug(input1); |
| Plug(output3); |
| ASSERT_EQ(ActiveInputNodeId(), input1.id); |
| ASSERT_EQ(ActiveOutputNodeId(), output3.id); |
| Plug(input2); |
| Plug(output4); |
| ASSERT_EQ(ActiveInputNodeId(), input2.id); |
| ASSERT_EQ(ActiveOutputNodeId(), output4.id); |
| // Automatic switches should not generate events. |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInput), |
| 0); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutput), |
| 0); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInputOverridden), |
| 0); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutputOverridden), |
| 0); |
| } |
| |
| { |
| base::UserActionTester actions; |
| Select(input1); |
| ASSERT_EQ(ActiveInputNodeId(), input1.id); |
| ASSERT_EQ(ActiveOutputNodeId(), output4.id); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInput), |
| 1); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutput), |
| 0); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInputOverridden), |
| 1); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutputOverridden), |
| 0); |
| } |
| |
| { |
| base::UserActionTester actions; |
| Select(output3); |
| ASSERT_EQ(ActiveInputNodeId(), input1.id); |
| ASSERT_EQ(ActiveOutputNodeId(), output3.id); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInput), |
| 0); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutput), |
| 1); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInputOverridden), |
| 0); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutputOverridden), |
| 1); |
| } |
| |
| { |
| base::UserActionTester actions; |
| Select(input2); |
| Select(output4); |
| ASSERT_EQ(ActiveInputNodeId(), input2.id); |
| ASSERT_EQ(ActiveOutputNodeId(), output4.id); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInput), |
| 1); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutput), |
| 1); |
| // Switching back and forth should not be counted. |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInputOverridden), |
| 0); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutputOverridden), |
| 0); |
| } |
| |
| { |
| base::UserActionTester actions; |
| Unplug(input1); |
| Plug(input1); |
| ASSERT_EQ(ActiveInputNodeId(), input2.id); |
| Select(input1); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInput), |
| 1); |
| // Switching after the system decides to do nothing, should be counted. |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchInputOverridden), |
| 1); |
| } |
| |
| { |
| base::UserActionTester actions; |
| Unplug(output3); |
| Plug(output3); |
| ASSERT_EQ(ActiveOutputNodeId(), output4.id); |
| Select(output3); |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutput), |
| 1); |
| // Switching after the system decides to do nothing, should be counted. |
| EXPECT_EQ(actions.GetActionCount( |
| AudioDeviceMetricsHandler::kUserActionSwitchOutputOverridden), |
| 1); |
| } |
| } |
| |
| TEST_F(AudioDeviceSelectionTest, PlugUnplugHistogramMetrics) { |
| // Time delta constant for testing the user override system decision. |
| constexpr uint16_t kTimeDeltaInMinuteA = 2; |
| constexpr uint16_t kTimeDeltaInMinuteB = 30; |
| constexpr uint16_t kTimeDeltaInMinuteC = 200; |
| |
| AudioNode input_internal = NewInputNode("INTERNAL_MIC"); |
| AudioNode input_USB = NewInputNode("USB"); |
| AudioNode input_bluetooth_nb = NewInputNode("BLUETOOTH_NB_MIC"); |
| AudioNode output_internal = NewOutputNode("INTERNAL_SPEAKER"); |
| AudioNode output_USB = NewOutputNode("USB"); |
| |
| uint16_t expected_system_switch_input_count = 0; |
| uint16_t expected_system_not_switch_input_count = 0; |
| uint16_t expected_system_switch_output_count = 0; |
| uint16_t expected_system_not_switch_output_count = 0; |
| |
| uint16_t expected_user_override_system_switch_input_count = 0; |
| uint16_t expected_user_override_system_not_switch_input_count = 0; |
| uint16_t expected_user_override_system_switch_output_count = 0; |
| uint16_t expected_user_override_system_not_switch_output_count = 0; |
| |
| uint16_t expected_user_override_system_switch_input_count_in_limited_time = 0; |
| uint16_t |
| expected_user_override_system_not_switch_input_count_in_limited_time = 0; |
| uint16_t expected_user_override_system_switch_output_count_in_limited_time = |
| 0; |
| uint16_t |
| expected_user_override_system_not_switch_output_count_in_limited_time = 0; |
| |
| uint16_t num_of_input_devices = 0; |
| uint16_t num_of_output_devices = 0; |
| |
| uint16_t expected_consecutive_input_device_changed = 0; |
| uint16_t expected_consecutive_output_device_changed = 0; |
| uint16_t expected_consecutive_input_device_added = 0; |
| uint16_t expected_consecutive_output_device_added = 0; |
| |
| // Plug in internal mic and speaker. |
| // Do not record if there is no alternative device available. |
| Plug(input_internal); |
| Plug(output_internal); |
| num_of_input_devices++; |
| num_of_output_devices++; |
| |
| ExpectSystemDecisionHistogramCount( |
| histogram_tester(), expected_system_switch_input_count, |
| expected_system_not_switch_input_count, |
| expected_system_switch_output_count, |
| expected_system_not_switch_output_count, /*is_chrome_restarts=*/false); |
| |
| ExpectConsecutiveDeviceChangeHistogramCount( |
| histogram_tester(), expected_consecutive_input_device_changed, |
| expected_consecutive_output_device_changed, |
| expected_consecutive_input_device_added, |
| expected_consecutive_output_device_added); |
| |
| // Plug in USB devices with higher priority than current active one. |
| // Expect to record system has switched both input and output. |
| Plug(input_USB); |
| Plug(output_USB); |
| num_of_input_devices++; |
| num_of_output_devices++; |
| |
| ExpectSystemDecisionHistogramCount( |
| histogram_tester(), ++expected_system_switch_input_count, |
| expected_system_not_switch_input_count, |
| ++expected_system_switch_output_count, |
| expected_system_not_switch_output_count, /*is_chrome_restarts=*/false); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioDeviceCount, |
| num_of_input_devices, /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioDeviceCount, |
| num_of_output_devices, /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputAudioDeviceCountNonChromeRestarts, |
| num_of_input_devices, /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputAudioDeviceCountNonChromeRestarts, |
| num_of_output_devices, /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioDeviceSet, |
| EncodeAudioDeviceSet( |
| {AudioDevice(input_internal), AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioDeviceSet, |
| EncodeAudioDeviceSet( |
| {AudioDevice(output_internal), AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputAudioDeviceSetNonChromeRestarts, |
| EncodeAudioDeviceSet( |
| {AudioDevice(output_internal), AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputAudioDeviceSetNonChromeRestarts, |
| EncodeAudioDeviceSet( |
| {AudioDevice(output_internal), AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputBeforeAndAfterAudioDeviceSetNonChromeRestarts, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputBeforeAndAfterAudioDeviceSetNonChromeRestarts, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| |
| ExpectConsecutiveDeviceChangeHistogramCount( |
| histogram_tester(), ++expected_consecutive_input_device_changed, |
| ++expected_consecutive_output_device_changed, |
| ++expected_consecutive_input_device_added, |
| ++expected_consecutive_output_device_added); |
| |
| // User switches input device immediately. |
| // Expect to record user overrides system decision of switching input |
| // device. |
| Select(input_internal); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(input_internal)}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| |
| ExpectUserOverrideSystemDecisionHistogramCount( |
| histogram_tester(), ++expected_user_override_system_switch_input_count, |
| expected_user_override_system_not_switch_input_count, |
| expected_user_override_system_switch_output_count, |
| expected_user_override_system_not_switch_output_count, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionHistogramCountInLimitedTime( |
| histogram_tester(), |
| ++expected_user_override_system_switch_input_count_in_limited_time, |
| expected_user_override_system_not_switch_input_count_in_limited_time, |
| expected_user_override_system_switch_output_count_in_limited_time, |
| expected_user_override_system_not_switch_output_count_in_limited_time, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionTimeDelta( |
| histogram_tester(), /*is_input=*/true, /*system_has_switched=*/true, |
| /*delta_in_minute=*/0, /*is_chrome_restarts=*/false); |
| |
| // User switches output device after some time. |
| // Expect to record user overrides system decision of switching output |
| // device. |
| FastForwardBy(base::Minutes(kTimeDeltaInMinuteA)); |
| Select(output_internal); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchOutputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| |
| ExpectUserOverrideSystemDecisionHistogramCount( |
| histogram_tester(), expected_user_override_system_switch_input_count, |
| expected_user_override_system_not_switch_input_count, |
| ++expected_user_override_system_switch_output_count, |
| expected_user_override_system_not_switch_output_count, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionHistogramCountInLimitedTime( |
| histogram_tester(), |
| expected_user_override_system_switch_input_count_in_limited_time, |
| expected_user_override_system_not_switch_input_count_in_limited_time, |
| ++expected_user_override_system_switch_output_count_in_limited_time, |
| expected_user_override_system_not_switch_output_count_in_limited_time, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionTimeDelta( |
| histogram_tester(), /*is_input=*/false, /*system_has_switched=*/true, |
| /*delta_in_minute=*/kTimeDeltaInMinuteA, /*is_chrome_restarts=*/false); |
| |
| // User switches output device again. |
| // Do not record since user has just switched output device previously and |
| // there is no system switch or not switch decision in between. |
| Select(output_USB); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchOutputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| |
| ExpectUserOverrideSystemDecisionHistogramCount( |
| histogram_tester(), expected_user_override_system_switch_input_count, |
| expected_user_override_system_not_switch_input_count, |
| expected_user_override_system_switch_output_count, |
| expected_user_override_system_not_switch_output_count, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionHistogramCountInLimitedTime( |
| histogram_tester(), |
| expected_user_override_system_switch_input_count_in_limited_time, |
| expected_user_override_system_not_switch_input_count_in_limited_time, |
| expected_user_override_system_switch_output_count_in_limited_time, |
| expected_user_override_system_not_switch_output_count_in_limited_time, |
| /*is_chrome_restarts=*/false); |
| |
| // Plug in a bluetooth nb mic with lower priority than current active one. |
| // Expect to record system does not switch input. |
| Plug(input_bluetooth_nb); |
| num_of_input_devices++; |
| |
| ExpectSystemDecisionHistogramCount( |
| histogram_tester(), expected_system_switch_input_count, |
| ++expected_system_not_switch_input_count, |
| expected_system_switch_output_count, |
| expected_system_not_switch_output_count, /*is_chrome_restarts=*/false); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemNotSwitchInputAudioDeviceCount, |
| num_of_input_devices, /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemNotSwitchInputAudioDeviceCountNonChromeRestarts, |
| num_of_input_devices, /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemNotSwitchInputAudioDeviceSet, |
| EncodeAudioDeviceSet({AudioDevice(input_internal), AudioDevice(input_USB), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemNotSwitchInputAudioDeviceSetNonChromeRestarts, |
| EncodeAudioDeviceSet({AudioDevice(input_internal), AudioDevice(input_USB), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemNotSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemNotSwitchInputBeforeAndAfterAudioDeviceSetNonChromeRestarts, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB)}, |
| /*device_set_after=*/{AudioDevice(output_internal), |
| AudioDevice(output_USB), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| ExpectConsecutiveDeviceChangeHistogramCount( |
| histogram_tester(), ++expected_consecutive_input_device_changed, |
| expected_consecutive_output_device_changed, |
| ++expected_consecutive_input_device_added, |
| expected_consecutive_output_device_added); |
| |
| // User switches to USB input after some time. |
| // Expect to record user overrides system decision of not switching input |
| // device. |
| FastForwardBy(base::Minutes(kTimeDeltaInMinuteB)); |
| Select(input_USB); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemNotSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB)}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| ExpectUserOverrideSystemDecisionHistogramCount( |
| histogram_tester(), expected_user_override_system_switch_input_count, |
| ++expected_user_override_system_not_switch_input_count, |
| expected_user_override_system_switch_output_count, |
| expected_user_override_system_not_switch_output_count, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionHistogramCountInLimitedTime( |
| histogram_tester(), |
| expected_user_override_system_switch_input_count_in_limited_time, |
| ++expected_user_override_system_not_switch_input_count_in_limited_time, |
| expected_user_override_system_switch_output_count_in_limited_time, |
| expected_user_override_system_not_switch_output_count_in_limited_time, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionTimeDelta( |
| histogram_tester(), /*is_input=*/true, /*system_has_switched=*/false, |
| /*delta_in_minute=*/kTimeDeltaInMinuteB, /*is_chrome_restarts=*/false); |
| |
| // User unplugs current active device USB input. |
| // Expect to record system has switched input. |
| Unplug(input_USB); |
| num_of_input_devices--; |
| |
| ExpectSystemDecisionHistogramCount( |
| histogram_tester(), ++expected_system_switch_input_count, |
| expected_system_not_switch_input_count, |
| expected_system_switch_output_count, |
| expected_system_not_switch_output_count, /*is_chrome_restarts=*/false); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioDeviceCount, |
| num_of_input_devices, /*bucket_count=*/2); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputAudioDeviceCountNonChromeRestarts, |
| num_of_input_devices, /*bucket_count=*/2); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioDeviceSet, |
| EncodeAudioDeviceSet( |
| {AudioDevice(input_internal), AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputAudioDeviceSetNonChromeRestarts, |
| EncodeAudioDeviceSet( |
| {AudioDevice(input_internal), AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(input_internal), |
| AudioDevice(input_bluetooth_nb), |
| AudioDevice(input_USB)}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputBeforeAndAfterAudioDeviceSetNonChromeRestarts, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(input_internal), |
| AudioDevice(input_bluetooth_nb), |
| AudioDevice(input_USB)}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| ExpectConsecutiveDeviceChangeHistogramCount( |
| histogram_tester(), ++expected_consecutive_input_device_changed, |
| expected_consecutive_output_device_changed, |
| expected_consecutive_input_device_added, |
| expected_consecutive_output_device_added); |
| |
| // User switches to input_bluetooth_nb after some time. |
| // Expect to record user overrides system decision of switching input device. |
| FastForwardBy(base::Minutes(kTimeDeltaInMinuteC)); |
| Select(input_bluetooth_nb); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{AudioDevice(input_internal), |
| AudioDevice(input_bluetooth_nb), |
| AudioDevice(input_USB)}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_bluetooth_nb)}), |
| /*bucket_count=*/1); |
| |
| ExpectUserOverrideSystemDecisionHistogramCount( |
| histogram_tester(), ++expected_user_override_system_switch_input_count, |
| expected_user_override_system_not_switch_input_count, |
| expected_user_override_system_switch_output_count, |
| expected_user_override_system_not_switch_output_count, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionHistogramCountInLimitedTime( |
| histogram_tester(), |
| expected_user_override_system_switch_input_count_in_limited_time, |
| expected_user_override_system_not_switch_input_count_in_limited_time, |
| expected_user_override_system_switch_output_count_in_limited_time, |
| expected_user_override_system_not_switch_output_count_in_limited_time, |
| /*is_chrome_restarts=*/false); |
| ExpectUserOverrideSystemDecisionTimeDelta( |
| histogram_tester(), /*is_input=*/true, /*system_has_switched=*/true, |
| /*delta_in_minute=*/kTimeDeltaInMinuteC, /*is_chrome_restarts=*/false); |
| |
| // User unplugs active device input_bluetooth_nb. |
| // Do not record if there is no alternative device available. |
| Unplug(input_bluetooth_nb); |
| |
| ExpectSystemDecisionHistogramCount( |
| histogram_tester(), expected_system_switch_input_count, |
| expected_system_not_switch_input_count, |
| expected_system_switch_output_count, |
| expected_system_not_switch_output_count, /*is_chrome_restarts=*/false); |
| |
| ExpectConsecutiveDeviceChangeHistogramCount( |
| histogram_tester(), ++expected_consecutive_input_device_changed, |
| expected_consecutive_output_device_changed, |
| expected_consecutive_input_device_added, |
| expected_consecutive_output_device_added); |
| } |
| |
| TEST_F(AudioDeviceSelectionTest, SystemBootsHistogramMetrics) { |
| AudioNode input_internal = NewInputNode("INTERNAL_MIC"); |
| AudioNode input_USB = NewInputNode("USB"); |
| AudioNode output_internal = NewOutputNode("INTERNAL_SPEAKER"); |
| AudioNode output_USB = NewOutputNode("USB"); |
| |
| uint16_t expected_system_switch_input_count = 0; |
| uint16_t expected_system_not_switch_input_count = 0; |
| uint16_t expected_system_switch_output_count = 0; |
| uint16_t expected_system_not_switch_output_count = 0; |
| |
| uint16_t num_of_input_devices = 0; |
| uint16_t num_of_output_devices = 0; |
| |
| uint16_t expected_user_override_system_switch_input_count = 0; |
| uint16_t expected_user_override_system_not_switch_input_count = 0; |
| uint16_t expected_user_override_system_switch_output_count = 0; |
| uint16_t expected_user_override_system_not_switch_output_count = 0; |
| |
| uint16_t expected_user_override_system_switch_input_count_in_limited_time = 0; |
| uint16_t |
| expected_user_override_system_not_switch_input_count_in_limited_time = 0; |
| uint16_t expected_user_override_system_switch_output_count_in_limited_time = |
| 0; |
| uint16_t |
| expected_user_override_system_not_switch_output_count_in_limited_time = 0; |
| |
| // System boots with multiple audio devices. |
| // Expect to record system has switched both input and output. |
| SystemBootsWith({input_internal, input_USB, output_internal, output_USB}); |
| num_of_input_devices += 2; |
| num_of_output_devices += 2; |
| |
| ExpectSystemDecisionHistogramCount( |
| histogram_tester(), ++expected_system_switch_input_count, |
| expected_system_not_switch_input_count, |
| ++expected_system_switch_output_count, |
| expected_system_not_switch_output_count, /*is_chrome_restarts=*/true); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioDeviceCount, |
| num_of_input_devices, /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioDeviceCount, |
| num_of_output_devices, /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputAudioDeviceCountChromeRestarts, |
| num_of_input_devices, /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputAudioDeviceCountChromeRestarts, |
| num_of_output_devices, /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioDeviceSet, |
| EncodeAudioDeviceSet( |
| {AudioDevice(input_internal), AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchOutputAudioDeviceSet, |
| EncodeAudioDeviceSet( |
| {AudioDevice(input_internal), AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputAudioDeviceSetChromeRestarts, |
| EncodeAudioDeviceSet( |
| {AudioDevice(output_internal), AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputAudioDeviceSetChromeRestarts, |
| EncodeAudioDeviceSet( |
| {AudioDevice(output_internal), AudioDevice(output_USB)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler::kSystemSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchInputBeforeAndAfterAudioDeviceSetChromeRestarts, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kSystemSwitchOutputBeforeAndAfterAudioDeviceSetChromeRestarts, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| |
| // Mock user switching to internal mic. |
| Select(input_internal); |
| |
| histogram_tester().ExpectBucketCount( |
| AudioDeviceMetricsHandler:: |
| kUserOverrideSystemSwitchInputBeforeAndAfterAudioDeviceSet, |
| EncodeBeforeAndAfterAudioDeviceSets( |
| /*device_set_before=*/{}, |
| /*device_set_after=*/{AudioDevice(input_internal), |
| AudioDevice(input_USB)}), |
| /*bucket_count=*/1); |
| |
| ExpectUserOverrideSystemDecisionHistogramCount( |
| histogram_tester(), ++expected_user_override_system_switch_input_count, |
| expected_user_override_system_not_switch_input_count, |
| expected_user_override_system_switch_output_count, |
| expected_user_override_system_not_switch_output_count, |
| /*is_chrome_restarts=*/true); |
| ExpectUserOverrideSystemDecisionHistogramCountInLimitedTime( |
| histogram_tester(), |
| ++expected_user_override_system_switch_input_count_in_limited_time, |
| expected_user_override_system_not_switch_input_count_in_limited_time, |
| expected_user_override_system_switch_output_count_in_limited_time, |
| expected_user_override_system_not_switch_output_count_in_limited_time, |
| /*is_chrome_restarts=*/true); |
| |
| ExpectUserOverrideSystemDecisionTimeDelta( |
| histogram_tester(), /*is_input=*/true, /*system_has_switched=*/true, |
| /*delta_in_minute=*/0, /*is_chrome_restarts=*/true); |
| } |
| |
| TEST_F(AudioDeviceSelectionTest, DevicePrefEviction) { |
| std::vector<AudioNode> nodes; |
| for (int i = 0; i < 101; i++) { |
| nodes.push_back(NewInputNode("USB")); |
| } |
| |
| Plug(nodes[0]); |
| for (int i = 1; i < 101; i++) { |
| FastForwardBy(base::Seconds(1)); |
| Plug(nodes[i]); |
| ASSERT_EQ(ActiveInputNodeId(), nodes[i].id) << " i = " << i; |
| ASSERT_NE(audio_pref_handler_->GetUserPriority(AudioDevice(nodes[i])), |
| kUserPriorityNone) |
| << " i = " << i; |
| |
| FastForwardBy(base::Seconds(1)); |
| Unplug(nodes[i]); |
| } |
| |
| // We store at most 100 devices in prefs. |
| EXPECT_NE(audio_pref_handler_->GetUserPriority(AudioDevice(nodes[0])), |
| kUserPriorityNone) |
| << "nodes[0] should be kept because it is connected"; |
| EXPECT_EQ(audio_pref_handler_->GetUserPriority(AudioDevice(nodes[1])), |
| kUserPriorityNone) |
| << "nodes[1] should be evicted because it is unplugged and the least " |
| "recently seen"; |
| for (int i = 2; i < 101; i++) { |
| EXPECT_NE(audio_pref_handler_->GetUserPriority(AudioDevice(nodes[i])), |
| kUserPriorityNone) |
| << "nodes[" << i |
| << "] should be kept because it is within the recent 100 seen devices"; |
| } |
| } |
| |
| } // namespace |
| |
| } // namespace ash |
