chromeos/audio/cras_audio_handler_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/audio/cras_audio_handler.h"
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/values.h"
  11 #include "chromeos/audio/audio_devices_pref_handler_stub.h"
  12 #include "chromeos/dbus/audio_node.h"
  13 #include "chromeos/dbus/cras_audio_client_stub_impl.h"
  14 #include "chromeos/dbus/dbus_thread_manager.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace chromeos {
  18
  19 const uint64 kInternalSpeakerId = 10001;
  20 const uint64 kHeadphoneId = 10002;
  21 const uint64 kInternalMicId = 10003;
  22 const uint64 kUSBMicId = 10004;
  23 const uint64 kBluetoothHeadsetId = 10005;
  24 const uint64 kHDMIOutputId = 10006;
  25 const uint64 kUSBHeadphoneId1 = 10007;
  26 const uint64 kUSBHeadphoneId2 = 10008;
  27 const uint64 kMicJackId = 10009;
  28 const uint64 kOtherTypeOutputId = 90001;
  29 const uint64 kOtherTypeInputId = 90002;
  30
  31 const AudioNode kInternalSpeaker(
  32     false,
  33     kInternalSpeakerId,
  34     "Fake Speaker",
  35     "INTERNAL_SPEAKER",
  36     "Speaker",
  37     false,
  38     0
  39 );
  40
  41 const AudioNode kHeadphone(
  42     false,
  43     kHeadphoneId,
  44     "Fake Headphone",
  45     "HEADPHONE",
  46     "Headphone",
  47     false,
  48     0
  49 );
  50
  51 const AudioNode kInternalMic(
  52     true,
  53     kInternalMicId,
  54     "Fake Mic",
  55     "INTERNAL_MIC",
  56     "Internal Mic",
  57     false,
  58     0
  59 );
  60
  61 const AudioNode kMicJack(
  62     true,
  63     kMicJackId,
  64     "Fake Mic Jack",
  65     "MIC",
  66     "Mic Jack",
  67     false,
  68     0
  69 );
  70
  71 const AudioNode kUSBMic(
  72     true,
  73     kUSBMicId,
  74     "Fake USB Mic",
  75     "USB",
  76     "USB Microphone",
  77     false,
  78     0
  79 );
  80
  81 const AudioNode kOtherTypeOutput(
  82     false,
  83     kOtherTypeOutputId,
  84     "Output Device",
  85     "SOME_OTHER_TYPE",
  86     "Other Type Output Device",
  87     false,
  88     0
  89 );
  90
  91 const AudioNode kOtherTypeInput(
  92     true,
  93     kOtherTypeInputId,
  94     "Input Device",
  95     "SOME_OTHER_TYPE",
  96     "Other Type Input Device",
  97     false,
  98     0
  99 );
 100
 101 const AudioNode kBluetoothHeadset (
 102     false,
 103     kBluetoothHeadsetId,
 104     "Bluetooth Headset",
 105     "BLUETOOTH",
 106     "Bluetooth Headset 1",
 107     false,
 108     0
 109 );
 110
 111 const AudioNode kHDMIOutput (
 112     false,
 113     kHDMIOutputId,
 114     "HDMI output",
 115     "HDMI",
 116     "HDMI output",
 117     false,
 118     0
 119 );
 120
 121 const AudioNode kUSBHeadphone1 (
 122     false,
 123     kUSBHeadphoneId1,
 124     "USB Headphone",
 125     "USB",
 126     "USB Headphone 1",
 127     false,
 128     0
 129 );
 130
 131 const AudioNode kUSBHeadphone2 (
 132     false,
 133     kUSBHeadphoneId2,
 134     "USB Headphone",
 135     "USB",
 136     "USB Headphone 1",
 137     false,
 138     0
 139 );
 140
 141
 142 class TestObserver : public chromeos::CrasAudioHandler::AudioObserver {
 143  public:
 144   TestObserver() : active_output_node_changed_count_(0),
 145                    active_input_node_changed_count_(0),
 146                    audio_nodes_changed_count_(0),
 147                    output_mute_changed_count_(0),
 148                    input_mute_changed_count_(0),
 149                    output_volume_changed_count_(0),
 150                    input_gain_changed_count_(0) {
 151   }
 152
 153   int active_output_node_changed_count() const {
 154     return active_output_node_changed_count_;
 155   }
 156
 157   int active_input_node_changed_count() const {
 158     return active_input_node_changed_count_;
 159   }
 160
 161   int audio_nodes_changed_count() const {
 162     return audio_nodes_changed_count_;
 163   }
 164
 165   int output_mute_changed_count() const {
 166     return output_mute_changed_count_;
 167   }
 168
 169   int input_mute_changed_count() const {
 170     return input_mute_changed_count_;
 171   }
 172
 173   int output_volume_changed_count() const {
 174     return output_volume_changed_count_;
 175   }
 176
 177   int input_gain_changed_count() const {
 178     return input_gain_changed_count_;
 179   }
 180
 181   virtual ~TestObserver() {}
 182
 183  protected:
 184   // chromeos::CrasAudioHandler::AudioObserver overrides.
 185   virtual void OnActiveOutputNodeChanged() OVERRIDE {
 186     ++active_output_node_changed_count_;
 187   }
 188
 189   virtual void OnActiveInputNodeChanged() OVERRIDE {
 190     ++active_input_node_changed_count_;
 191   }
 192
 193   virtual void OnAudioNodesChanged() OVERRIDE {
 194     ++audio_nodes_changed_count_;
 195   }
 196
 197   virtual void OnOutputMuteChanged() OVERRIDE {
 198     ++output_mute_changed_count_;
 199   }
 200
 201   virtual void OnInputMuteChanged() OVERRIDE {
 202     ++input_mute_changed_count_;
 203   }
 204
 205   virtual void OnOutputVolumeChanged() OVERRIDE {
 206     ++output_volume_changed_count_;
 207   }
 208
 209   virtual void OnInputGainChanged() OVERRIDE {
 210     ++input_gain_changed_count_;
 211   }
 212
 213  private:
 214   int active_output_node_changed_count_;
 215   int active_input_node_changed_count_;
 216   int audio_nodes_changed_count_;
 217   int output_mute_changed_count_;
 218   int input_mute_changed_count_;
 219   int output_volume_changed_count_;
 220   int input_gain_changed_count_;
 221
 222   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 223 };
 224
 225 class CrasAudioHandlerTest : public testing::Test {
 226  public:
 227   CrasAudioHandlerTest() : cras_audio_handler_(NULL),
 228                            cras_audio_client_stub_(NULL) {
 229   }
 230   virtual ~CrasAudioHandlerTest() {}
 231
 232   virtual void SetUp() OVERRIDE {
 233   }
 234
 235   virtual void TearDown() OVERRIDE {
 236     cras_audio_handler_->RemoveAudioObserver(test_observer_.get());
 237     test_observer_.reset();
 238     CrasAudioHandler::Shutdown();
 239     audio_pref_handler_ = NULL;
 240     DBusThreadManager::Shutdown();
 241   }
 242
 243   void SetUpCrasAudioHandler(const AudioNodeList& audio_nodes) {
 244     DBusThreadManager::InitializeWithStub();
 245     cras_audio_client_stub_ = static_cast<CrasAudioClientStubImpl*>(
 246         DBusThreadManager::Get()->GetCrasAudioClient());
 247     cras_audio_client_stub_->SetAudioDevices(audio_nodes);
 248     audio_pref_handler_ = new AudioDevicesPrefHandlerStub();
 249     CrasAudioHandler::Initialize(audio_pref_handler_);
 250     cras_audio_handler_ = CrasAudioHandler::Get();
 251     test_observer_.reset(new TestObserver);
 252     cras_audio_handler_->AddAudioObserver(test_observer_.get());
 253     message_loop_.RunUntilIdle();
 254   }
 255
 256   void ChangeAudioNodes(const AudioNodeList& audio_nodes) {
 257     cras_audio_client_stub_->ChangeAudioNodes(audio_nodes);
 258     message_loop_.RunUntilIdle();
 259   }
 260
 261  protected:
 262   base::MessageLoopForUI message_loop_;
 263   CrasAudioHandler* cras_audio_handler_;  // Not owned.
 264   CrasAudioClientStubImpl* cras_audio_client_stub_;  // Not owned.
 265   scoped_ptr<TestObserver> test_observer_;
 266   scoped_refptr<AudioDevicesPrefHandlerStub> audio_pref_handler_;
 267
 268  private:
 269   DISALLOW_COPY_AND_ASSIGN(CrasAudioHandlerTest);
 270 };
 271
 272 TEST_F(CrasAudioHandlerTest, InitializeWithOnlyDefaultAudioDevices) {
 273   AudioNodeList audio_nodes;
 274   audio_nodes.push_back(kInternalSpeaker);
 275   audio_nodes.push_back(kInternalMic);
 276   SetUpCrasAudioHandler(audio_nodes);
 277
 278   // Verify the audio devices size.
 279   AudioDeviceList audio_devices;
 280   cras_audio_handler_->GetAudioDevices(&audio_devices);
 281   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 282
 283   // Verify the internal speaker has been selected as the active output.
 284   AudioDevice active_output;
 285   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 286   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 287   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 288   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
 289
 290   // Ensure the internal microphone has been selected as the active input.
 291   AudioDevice active_input;
 292   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
 293   EXPECT_FALSE(cras_audio_handler_->has_alternative_input());
 294 }
 295
 296 TEST_F(CrasAudioHandlerTest, InitializeWithAlternativeAudioDevices) {
 297   AudioNodeList audio_nodes;
 298   audio_nodes.push_back(kInternalSpeaker);
 299   audio_nodes.push_back(kHeadphone);
 300   audio_nodes.push_back(kInternalMic);
 301   audio_nodes.push_back(kUSBMic);
 302   SetUpCrasAudioHandler(audio_nodes);
 303
 304   // Verify the audio devices size.
 305   AudioDeviceList audio_devices;
 306   cras_audio_handler_->GetAudioDevices(&audio_devices);
 307   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 308
 309   // Verify the headphone has been selected as the active output.
 310   AudioDevice active_output;
 311   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 312   EXPECT_EQ(kHeadphone.id, active_output.id);
 313   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 314   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 315
 316   // Ensure the USB microphone has been selected as the active input.
 317   AudioDevice active_input;
 318   EXPECT_EQ(kUSBMicId, cras_audio_handler_->GetActiveInputNode());
 319   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
 320 }
 321
 322 TEST_F(CrasAudioHandlerTest, SwitchActiveOutputDevice) {
 323   AudioNodeList audio_nodes;
 324   audio_nodes.push_back(kInternalSpeaker);
 325   audio_nodes.push_back(kHeadphone);
 326   SetUpCrasAudioHandler(audio_nodes);
 327   AudioDeviceList audio_devices;
 328   cras_audio_handler_->GetAudioDevices(&audio_devices);
 329   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 330
 331   // Verify the initial active output device is headphone.
 332   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 333   AudioDevice active_output;
 334   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 335   EXPECT_EQ(kHeadphone.id, active_output.id);
 336   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 337
 338   // Switch the active output to internal speaker.
 339   AudioDevice internal_speaker(kInternalSpeaker);
 340   cras_audio_handler_->SwitchToDevice(internal_speaker);
 341
 342   // Verify the active output is switched to internal speaker, and the
 343   // ActiveOutputNodeChanged event is fired.
 344   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 345   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 346   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 347   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 348 }
 349
 350 TEST_F(CrasAudioHandlerTest, SwitchActiveInputDevice) {
 351   AudioNodeList audio_nodes;
 352   audio_nodes.push_back(kInternalMic);
 353   audio_nodes.push_back(kUSBMic);
 354   SetUpCrasAudioHandler(audio_nodes);
 355   AudioDeviceList audio_devices;
 356   cras_audio_handler_->GetAudioDevices(&audio_devices);
 357   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 358
 359   // Verify the initial active input device is USB mic.
 360   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
 361   EXPECT_EQ(kUSBMicId, cras_audio_handler_->GetActiveInputNode());
 362
 363   // Switch the active input to internal mic.
 364   AudioDevice internal_mic(kInternalMic);
 365   cras_audio_handler_->SwitchToDevice(internal_mic);
 366
 367   // Verify the active output is switched to internal speaker, and the active
 368   // ActiveInputNodeChanged event is fired.
 369   EXPECT_EQ(1, test_observer_->active_input_node_changed_count());
 370   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
 371 }
 372
 373 TEST_F(CrasAudioHandlerTest, PlugHeadphone) {
 374   // Set up initial audio devices, only with internal speaker.
 375   AudioNodeList audio_nodes;
 376   audio_nodes.push_back(kInternalSpeaker);
 377   SetUpCrasAudioHandler(audio_nodes);
 378   const size_t init_nodes_size = audio_nodes.size();
 379
 380   // Verify the audio devices size.
 381   AudioDeviceList audio_devices;
 382   cras_audio_handler_->GetAudioDevices(&audio_devices);
 383   EXPECT_EQ(init_nodes_size, audio_devices.size());
 384   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 385
 386   // Verify the internal speaker has been selected as the active output.
 387   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 388   AudioDevice active_output;
 389   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 390   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 391   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 392   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
 393
 394   // Plug the headphone.
 395   audio_nodes.clear();
 396   AudioNode internal_speaker(kInternalSpeaker);
 397   internal_speaker.active = true;
 398   audio_nodes.push_back(internal_speaker);
 399   audio_nodes.push_back(kHeadphone);
 400   ChangeAudioNodes(audio_nodes);
 401
 402   // Verify the AudioNodesChanged event is fired and new audio device is added.
 403   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 404   cras_audio_handler_->GetAudioDevices(&audio_devices);
 405   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
 406
 407   // Verify the active output device is switched to headphone and
 408   // ActiveOutputChanged event is fired.
 409   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 410   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 411   EXPECT_EQ(kHeadphone.id, active_output.id);
 412   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 413   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 414 }
 415
 416 TEST_F(CrasAudioHandlerTest, UnplugHeadphone) {
 417   // Set up initial audio devices, with internal speaker and headphone.
 418   AudioNodeList audio_nodes;
 419   audio_nodes.push_back(kInternalSpeaker);
 420   audio_nodes.push_back(kHeadphone);
 421   SetUpCrasAudioHandler(audio_nodes);
 422   const size_t init_nodes_size = audio_nodes.size();
 423
 424   // Verify the audio devices size.
 425   AudioDeviceList audio_devices;
 426   cras_audio_handler_->GetAudioDevices(&audio_devices);
 427   EXPECT_EQ(init_nodes_size, audio_devices.size());
 428   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 429
 430   // Verify the headphone has been selected as the active output.
 431   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 432   AudioDevice active_output;
 433   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 434   EXPECT_EQ(kHeadphone.id, active_output.id);
 435   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 436   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 437
 438   // Unplug the headphone.
 439   audio_nodes.clear();
 440   audio_nodes.push_back(kInternalSpeaker);
 441   ChangeAudioNodes(audio_nodes);
 442
 443   // Verify the AudioNodesChanged event is fired and one audio device is
 444   // removed.
 445   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 446   cras_audio_handler_->GetAudioDevices(&audio_devices);
 447   EXPECT_EQ(init_nodes_size - 1, audio_devices.size());
 448
 449   // Verify the active output device is switched to internal speaker and
 450   // ActiveOutputChanged event is fired.
 451   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 452   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 453   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 454   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 455   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
 456 }
 457
 458 TEST_F(CrasAudioHandlerTest, InitializeWithBluetoothHeadset) {
 459   AudioNodeList audio_nodes;
 460   audio_nodes.push_back(kInternalSpeaker);
 461   audio_nodes.push_back(kBluetoothHeadset);
 462   SetUpCrasAudioHandler(audio_nodes);
 463
 464   // Verify the audio devices size.
 465   AudioDeviceList audio_devices;
 466   cras_audio_handler_->GetAudioDevices(&audio_devices);
 467   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 468   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 469
 470   // Verify the bluetooth headset has been selected as the active output.
 471   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 472   AudioDevice active_output;
 473   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 474   EXPECT_EQ(kBluetoothHeadset.id, active_output.id);
 475   EXPECT_EQ(kBluetoothHeadset.id, cras_audio_handler_->GetActiveOutputNode());
 476   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 477 }
 478
 479 TEST_F(CrasAudioHandlerTest, ConnectAndDisconnectBluetoothHeadset) {
 480   // Initialize with internal speaker and headphone.
 481   AudioNodeList audio_nodes;
 482   audio_nodes.push_back(kInternalSpeaker);
 483   audio_nodes.push_back(kHeadphone);
 484   SetUpCrasAudioHandler(audio_nodes);
 485   const size_t init_nodes_size = audio_nodes.size();
 486
 487   // Verify the audio devices size.
 488   AudioDeviceList audio_devices;
 489   cras_audio_handler_->GetAudioDevices(&audio_devices);
 490   EXPECT_EQ(init_nodes_size, audio_devices.size());
 491   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 492
 493   // Verify the headphone is selected as the active output initially.
 494   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 495   AudioDevice active_output;
 496   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 497   EXPECT_EQ(kHeadphone.id, active_output.id);
 498   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 499   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 500
 501   // Connect to bluetooth headset. Since it is plugged in later than
 502   // headphone, active output should be switched to it.
 503   audio_nodes.clear();
 504   audio_nodes.push_back(kInternalSpeaker);
 505   AudioNode headphone(kHeadphone);
 506   headphone.plugged_time = 80000000;
 507   headphone.active = true;
 508   audio_nodes.push_back(headphone);
 509   AudioNode bluetooth_headset(kBluetoothHeadset);
 510   bluetooth_headset.plugged_time = 90000000;
 511   audio_nodes.push_back(bluetooth_headset);
 512   ChangeAudioNodes(audio_nodes);
 513
 514   // Verify the AudioNodesChanged event is fired and new audio device is added.
 515   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 516   cras_audio_handler_->GetAudioDevices(&audio_devices);
 517   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
 518
 519   // Verify the active output device is switched to bluetooth headset, and
 520   // ActiveOutputChanged event is fired.
 521   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 522   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 523   EXPECT_EQ(kBluetoothHeadset.id, active_output.id);
 524   EXPECT_EQ(kBluetoothHeadset.id, cras_audio_handler_->GetActiveOutputNode());
 525   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 526
 527   // Disconnect bluetooth headset.
 528   audio_nodes.clear();
 529   audio_nodes.push_back(kInternalSpeaker);
 530   headphone.active = false;
 531   audio_nodes.push_back(headphone);
 532   ChangeAudioNodes(audio_nodes);
 533
 534   // Verify the AudioNodesChanged event is fired and one audio device is
 535   // removed.
 536   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
 537   cras_audio_handler_->GetAudioDevices(&audio_devices);
 538   EXPECT_EQ(init_nodes_size, audio_devices.size());
 539
 540   // Verify the active output device is switched to headphone, and
 541   // ActiveOutputChanged event is fired.
 542   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
 543   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 544   EXPECT_EQ(kHeadphone.id, active_output.id);
 545   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 546   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 547 }
 548
 549 TEST_F(CrasAudioHandlerTest, InitializeWithHDMIOutput) {
 550   AudioNodeList audio_nodes;
 551   audio_nodes.push_back(kInternalSpeaker);
 552   audio_nodes.push_back(kHDMIOutput);
 553   SetUpCrasAudioHandler(audio_nodes);
 554
 555   // Verify the audio devices size.
 556   AudioDeviceList audio_devices;
 557   cras_audio_handler_->GetAudioDevices(&audio_devices);
 558   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 559   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 560
 561   // Verify the HDMI device has been selected as the active output.
 562   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 563   AudioDevice active_output;
 564   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 565   EXPECT_EQ(kHDMIOutput.id, active_output.id);
 566   EXPECT_EQ(kHDMIOutput.id, cras_audio_handler_->GetActiveOutputNode());
 567   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 568 }
 569
 570 TEST_F(CrasAudioHandlerTest, ConnectAndDisconnectHDMIOutput) {
 571   // Initialize with internal speaker.
 572   AudioNodeList audio_nodes;
 573   audio_nodes.push_back(kInternalSpeaker);
 574   SetUpCrasAudioHandler(audio_nodes);
 575   const size_t init_nodes_size = audio_nodes.size();
 576
 577   // Verify the audio devices size.
 578   AudioDeviceList audio_devices;
 579   cras_audio_handler_->GetAudioDevices(&audio_devices);
 580   EXPECT_EQ(init_nodes_size, audio_devices.size());
 581   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 582
 583   // Verify the internal speaker is selected as the active output initially.
 584   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 585   AudioDevice active_output;
 586   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 587   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 588   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 589   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
 590
 591   // Connect to HDMI output.
 592   audio_nodes.clear();
 593   AudioNode internal_speaker(kInternalSpeaker);
 594   internal_speaker.active = true;
 595   internal_speaker.plugged_time = 80000000;
 596   audio_nodes.push_back(internal_speaker);
 597   AudioNode hdmi(kHDMIOutput);
 598   hdmi.plugged_time = 90000000;
 599   audio_nodes.push_back(hdmi);
 600   ChangeAudioNodes(audio_nodes);
 601
 602   // Verify the AudioNodesChanged event is fired and new audio device is added.
 603   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 604   cras_audio_handler_->GetAudioDevices(&audio_devices);
 605   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
 606
 607   // Verify the active output device is switched to hdmi output, and
 608   // ActiveOutputChanged event is fired.
 609   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 610   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 611   EXPECT_EQ(kHDMIOutput.id, active_output.id);
 612   EXPECT_EQ(kHDMIOutput.id, cras_audio_handler_->GetActiveOutputNode());
 613   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 614
 615   // Disconnect hdmi headset.
 616   audio_nodes.clear();
 617   audio_nodes.push_back(kInternalSpeaker);
 618   ChangeAudioNodes(audio_nodes);
 619
 620   // Verify the AudioNodesChanged event is fired and one audio device is
 621   // removed.
 622   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
 623   cras_audio_handler_->GetAudioDevices(&audio_devices);
 624   EXPECT_EQ(init_nodes_size, audio_devices.size());
 625
 626   // Verify the active output device is switched to internal speaker, and
 627   // ActiveOutputChanged event is fired.
 628   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
 629   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 630   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 631   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 632   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
 633 }
 634
 635 TEST_F(CrasAudioHandlerTest, HandleHeadphoneAndHDMIOutput) {
 636   // Initialize with internal speaker, headphone and HDMI output.
 637   AudioNodeList audio_nodes;
 638   audio_nodes.push_back(kInternalSpeaker);
 639   audio_nodes.push_back(kHeadphone);
 640   audio_nodes.push_back(kHDMIOutput);
 641   SetUpCrasAudioHandler(audio_nodes);
 642   const size_t init_nodes_size = audio_nodes.size();
 643
 644   // Verify the audio devices size.
 645   AudioDeviceList audio_devices;
 646   cras_audio_handler_->GetAudioDevices(&audio_devices);
 647   EXPECT_EQ(init_nodes_size, audio_devices.size());
 648   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 649
 650   // Verify the headphone is selected as the active output initially.
 651   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 652   AudioDevice active_output;
 653   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 654   EXPECT_EQ(kHeadphone.id, active_output.id);
 655   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 656   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 657
 658   // Disconnect HDMI output.
 659   audio_nodes.clear();
 660   audio_nodes.push_back(kInternalSpeaker);
 661   audio_nodes.push_back(kHDMIOutput);
 662   ChangeAudioNodes(audio_nodes);
 663
 664   // Verify the AudioNodesChanged event is fired and one audio device is
 665   // removed.
 666   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 667   cras_audio_handler_->GetAudioDevices(&audio_devices);
 668   EXPECT_EQ(init_nodes_size - 1, audio_devices.size());
 669
 670   // Verify the active output device is switched to HDMI output, and
 671   // ActiveOutputChanged event is fired.
 672   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 673   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 674   EXPECT_EQ(kHDMIOutput.id, active_output.id);
 675   EXPECT_EQ(kHDMIOutput.id, cras_audio_handler_->GetActiveOutputNode());
 676   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 677 }
 678
 679 TEST_F(CrasAudioHandlerTest, InitializeWithUSBHeadphone) {
 680   AudioNodeList audio_nodes;
 681   audio_nodes.push_back(kInternalSpeaker);
 682   audio_nodes.push_back(kUSBHeadphone1);
 683   SetUpCrasAudioHandler(audio_nodes);
 684
 685   // Verify the audio devices size.
 686   AudioDeviceList audio_devices;
 687   cras_audio_handler_->GetAudioDevices(&audio_devices);
 688   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 689   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 690
 691   // Verify the usb headphone has been selected as the active output.
 692   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 693   AudioDevice active_output;
 694   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 695   EXPECT_EQ(kUSBHeadphone1.id, active_output.id);
 696   EXPECT_EQ(kUSBHeadphone1.id, cras_audio_handler_->GetActiveOutputNode());
 697   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 698 }
 699
 700 TEST_F(CrasAudioHandlerTest, PlugAndUnplugUSBHeadphone) {
 701   // Initialize with internal speaker.
 702   AudioNodeList audio_nodes;
 703   audio_nodes.push_back(kInternalSpeaker);
 704   SetUpCrasAudioHandler(audio_nodes);
 705   const size_t init_nodes_size = audio_nodes.size();
 706
 707   // Verify the audio devices size.
 708   AudioDeviceList audio_devices;
 709   cras_audio_handler_->GetAudioDevices(&audio_devices);
 710   EXPECT_EQ(init_nodes_size, audio_devices.size());
 711   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 712
 713   // Verify the internal speaker is selected as the active output initially.
 714   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 715   AudioDevice active_output;
 716   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 717   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 718   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 719   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
 720
 721   // Plug in usb headphone
 722   audio_nodes.clear();
 723   AudioNode internal_speaker(kInternalSpeaker);
 724   internal_speaker.active = true;
 725   internal_speaker.plugged_time = 80000000;
 726   audio_nodes.push_back(internal_speaker);
 727   AudioNode usb_headphone(kUSBHeadphone1);
 728   usb_headphone.plugged_time = 90000000;
 729   audio_nodes.push_back(usb_headphone);
 730   ChangeAudioNodes(audio_nodes);
 731
 732   // Verify the AudioNodesChanged event is fired and new audio device is added.
 733   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 734   cras_audio_handler_->GetAudioDevices(&audio_devices);
 735   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
 736
 737   // Verify the active output device is switched to usb headphone, and
 738   // ActiveOutputChanged event is fired.
 739   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 740   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 741   EXPECT_EQ(kUSBHeadphone1.id, active_output.id);
 742   EXPECT_EQ(kUSBHeadphone1.id, cras_audio_handler_->GetActiveOutputNode());
 743   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 744
 745   // Unplug usb headphone.
 746   audio_nodes.clear();
 747   audio_nodes.push_back(kInternalSpeaker);
 748   ChangeAudioNodes(audio_nodes);
 749
 750   // Verify the AudioNodesChanged event is fired and one audio device is
 751   // removed.
 752   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
 753   cras_audio_handler_->GetAudioDevices(&audio_devices);
 754   EXPECT_EQ(init_nodes_size, audio_devices.size());
 755
 756   // Verify the active output device is switched to internal speaker, and
 757   // ActiveOutputChanged event is fired.
 758   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
 759   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 760   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 761   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 762   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
 763 }
 764
 765 TEST_F(CrasAudioHandlerTest, HandleMultipleUSBHeadphones) {
 766   // Initialize with internal speaker and one usb headphone.
 767   AudioNodeList audio_nodes;
 768   audio_nodes.push_back(kInternalSpeaker);
 769   audio_nodes.push_back(kUSBHeadphone1);
 770   SetUpCrasAudioHandler(audio_nodes);
 771   const size_t init_nodes_size = audio_nodes.size();
 772
 773   // Verify the audio devices size.
 774   AudioDeviceList audio_devices;
 775   cras_audio_handler_->GetAudioDevices(&audio_devices);
 776   EXPECT_EQ(init_nodes_size, audio_devices.size());
 777   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 778
 779   // Verify the usb headphone is selected as the active output initially.
 780   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 781   AudioDevice active_output;
 782   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 783   EXPECT_EQ(kUSBHeadphone1.id, active_output.id);
 784   EXPECT_EQ(kUSBHeadphone1.id, cras_audio_handler_->GetActiveOutputNode());
 785   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 786
 787   // Plug in another usb headphone.
 788   audio_nodes.clear();
 789   audio_nodes.push_back(kInternalSpeaker);
 790   AudioNode usb_headphone_1(kUSBHeadphone1);
 791   usb_headphone_1.active = true;
 792   usb_headphone_1.plugged_time = 80000000;
 793   audio_nodes.push_back(usb_headphone_1);
 794   AudioNode usb_headphone_2(kUSBHeadphone2);
 795   usb_headphone_2.plugged_time = 90000000;
 796   audio_nodes.push_back(usb_headphone_2);
 797   ChangeAudioNodes(audio_nodes);
 798
 799   // Verify the AudioNodesChanged event is fired and new audio device is added.
 800   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 801   cras_audio_handler_->GetAudioDevices(&audio_devices);
 802   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
 803
 804   // Verify the active output device is switched to the 2nd usb headphone, which
 805   // is plugged later, and ActiveOutputChanged event is fired.
 806   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 807   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 808   EXPECT_EQ(kUSBHeadphone2.id, active_output.id);
 809   EXPECT_EQ(kUSBHeadphone2.id, cras_audio_handler_->GetActiveOutputNode());
 810   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 811
 812   // Unplug the 2nd usb headphone.
 813   audio_nodes.clear();
 814   audio_nodes.push_back(kInternalSpeaker);
 815   audio_nodes.push_back(kUSBHeadphone1);
 816   ChangeAudioNodes(audio_nodes);
 817
 818   // Verify the AudioNodesChanged event is fired and one audio device is
 819   // removed.
 820   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
 821   cras_audio_handler_->GetAudioDevices(&audio_devices);
 822   EXPECT_EQ(init_nodes_size, audio_devices.size());
 823
 824   // Verify the active output device is switched to the first usb headphone, and
 825   // ActiveOutputChanged event is fired.
 826   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
 827   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 828   EXPECT_EQ(kUSBHeadphone1.id, active_output.id);
 829   EXPECT_EQ(kUSBHeadphone1.id, cras_audio_handler_->GetActiveOutputNode());
 830   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 831 }
 832
 833 TEST_F(CrasAudioHandlerTest, UnplugUSBHeadphonesWithActiveSpeaker) {
 834   // Initialize with internal speaker and one usb headphone.
 835   AudioNodeList audio_nodes;
 836   audio_nodes.push_back(kInternalSpeaker);
 837   audio_nodes.push_back(kUSBHeadphone1);
 838   SetUpCrasAudioHandler(audio_nodes);
 839   const size_t init_nodes_size = audio_nodes.size();
 840
 841   // Verify the audio devices size.
 842   AudioDeviceList audio_devices;
 843   cras_audio_handler_->GetAudioDevices(&audio_devices);
 844   EXPECT_EQ(init_nodes_size, audio_devices.size());
 845   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 846
 847   // Verify the usb headphone is selected as the active output initially.
 848   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 849   AudioDevice active_output;
 850   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 851   EXPECT_EQ(kUSBHeadphone1.id, active_output.id);
 852   EXPECT_EQ(kUSBHeadphone1.id, cras_audio_handler_->GetActiveOutputNode());
 853   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 854
 855   // Plug in the headphone jack.
 856   audio_nodes.clear();
 857   audio_nodes.push_back(kInternalSpeaker);
 858   AudioNode usb_headphone_1(kUSBHeadphone1);
 859   usb_headphone_1.active = true;
 860   usb_headphone_1.plugged_time = 80000000;
 861   audio_nodes.push_back(usb_headphone_1);
 862   AudioNode headphone_jack(kHeadphone);
 863   headphone_jack.plugged_time = 90000000;
 864   audio_nodes.push_back(headphone_jack);
 865   ChangeAudioNodes(audio_nodes);
 866
 867   // Verify the AudioNodesChanged event is fired and new audio device is added.
 868   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 869   cras_audio_handler_->GetAudioDevices(&audio_devices);
 870   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
 871
 872   // Verify the active output device is switched to the headphone jack, which
 873   // is plugged later, and ActiveOutputChanged event is fired.
 874   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 875   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 876   EXPECT_EQ(kHeadphone.id, active_output.id);
 877   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 878   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 879
 880   // Select the speaker to be the active output device.
 881   AudioDevice internal_speaker(kInternalSpeaker);
 882   cras_audio_handler_->SwitchToDevice(internal_speaker);
 883
 884   // Verify the active output is switched to internal speaker, and the
 885   // ActiveOutputNodeChanged event is fired.
 886   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
 887   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 888   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 889   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 890
 891   // Unplug the usb headphone.
 892   audio_nodes.clear();
 893   AudioNode internal_speaker_node(kInternalSpeaker);
 894   internal_speaker_node.active = true;
 895   internal_speaker_node.plugged_time = 70000000;
 896   audio_nodes.push_back(internal_speaker_node);
 897   headphone_jack.active = false;
 898   audio_nodes.push_back(headphone_jack);
 899   ChangeAudioNodes(audio_nodes);
 900
 901   // Verify the AudioNodesChanged event is fired and one audio device is
 902   // removed.
 903   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
 904   cras_audio_handler_->GetAudioDevices(&audio_devices);
 905   EXPECT_EQ(init_nodes_size, audio_devices.size());
 906
 907   // Verify the active output device remains to be speaker.
 908   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
 909   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 910   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
 911   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
 912   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 913 }
 914
 915 TEST_F(CrasAudioHandlerTest, OneActiveAudioOutputAfterLoginNewUserSession) {
 916   // This tests the case found with crbug.com/273271.
 917   // Initialize with internal speaker, bluetooth headphone and headphone jack
 918   // for a new chrome session after user signs out from the previous session.
 919   // Headphone jack is plugged in later than bluetooth headphone, but bluetooth
 920   // headphone is selected as the active output by user from previous user
 921   // session.
 922   AudioNodeList audio_nodes;
 923   audio_nodes.push_back(kInternalSpeaker);
 924   AudioNode bluetooth_headphone(kBluetoothHeadset);
 925   bluetooth_headphone.active = true;
 926   bluetooth_headphone.plugged_time = 70000000;
 927   audio_nodes.push_back(bluetooth_headphone);
 928   AudioNode headphone_jack(kHeadphone);
 929   headphone_jack.plugged_time = 80000000;
 930   audio_nodes.push_back(headphone_jack);
 931   SetUpCrasAudioHandler(audio_nodes);
 932   const size_t init_nodes_size = audio_nodes.size();
 933
 934   // Verify the audio devices size.
 935   AudioDeviceList audio_devices;
 936   cras_audio_handler_->GetAudioDevices(&audio_devices);
 937   EXPECT_EQ(init_nodes_size, audio_devices.size());
 938   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 939
 940   // Verify the headphone jack is selected as the active output and all other
 941   // audio devices are not active.
 942   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 943   AudioDevice active_output;
 944   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 945   EXPECT_EQ(kHeadphone.id, active_output.id);
 946   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
 947   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 948   for (size_t i = 0; i < audio_devices.size(); ++i) {
 949     if (audio_devices[i].id != kHeadphone.id)
 950       EXPECT_FALSE(audio_devices[i].active);
 951   }
 952 }
 953
 954 TEST_F(CrasAudioHandlerTest, BluetoothSpeakerIdChangedOnFly) {
 955   // Initialize with internal speaker and bluetooth headset.
 956   AudioNodeList audio_nodes;
 957   audio_nodes.push_back(kInternalSpeaker);
 958   audio_nodes.push_back(kBluetoothHeadset);
 959   SetUpCrasAudioHandler(audio_nodes);
 960   const size_t init_nodes_size = audio_nodes.size();
 961
 962   // Verify the audio devices size.
 963   AudioDeviceList audio_devices;
 964   cras_audio_handler_->GetAudioDevices(&audio_devices);
 965   EXPECT_EQ(init_nodes_size, audio_devices.size());
 966   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
 967
 968   // Verify the bluetooth headset is selected as the active output and all other
 969   // audio devices are not active.
 970   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
 971   AudioDevice active_output;
 972   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
 973   EXPECT_EQ(kBluetoothHeadset.id, active_output.id);
 974   EXPECT_EQ(kBluetoothHeadset.id, cras_audio_handler_->GetActiveOutputNode());
 975   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 976
 977   // Cras changes the bluetooth headset's id on the fly.
 978   audio_nodes.clear();
 979   AudioNode internal_speaker(kInternalSpeaker);
 980   internal_speaker.active = false;
 981   audio_nodes.push_back(internal_speaker);
 982   AudioNode bluetooth_headphone(kBluetoothHeadset);
 983   // Change bluetooth headphone id.
 984   bluetooth_headphone.id = kBluetoothHeadsetId + 20000;
 985   bluetooth_headphone.active = false;
 986   audio_nodes.push_back(bluetooth_headphone);
 987   ChangeAudioNodes(audio_nodes);
 988
 989   // Verify NodesChanged event is fired, and the audio devices size is not
 990   // changed.
 991   audio_devices.clear();
 992   cras_audio_handler_->GetAudioDevices(&audio_devices);
 993   EXPECT_EQ(init_nodes_size, audio_devices.size());
 994   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
 995
 996   // Verify ActiveOutputNodeChanged event is fired, and active device should be
 997   // bluetooth headphone.
 998   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
 999   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
1000   EXPECT_EQ(bluetooth_headphone.id, active_output.id);
1001 }
1002
1003 TEST_F(CrasAudioHandlerTest, PlugUSBMic) {
1004   // Set up initial audio devices, only with internal mic.
1005   AudioNodeList audio_nodes;
1006   audio_nodes.push_back(kInternalMic);
1007   SetUpCrasAudioHandler(audio_nodes);
1008   const size_t init_nodes_size = audio_nodes.size();
1009
1010   // Verify the audio devices size.
1011   AudioDeviceList audio_devices;
1012   cras_audio_handler_->GetAudioDevices(&audio_devices);
1013   EXPECT_EQ(init_nodes_size, audio_devices.size());
1014   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
1015
1016   // Verify the internal mic is selected as the active input.
1017   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
1018   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
1019   EXPECT_FALSE(cras_audio_handler_->has_alternative_input());
1020
1021   // Plug the USB Mic.
1022   audio_nodes.clear();
1023   AudioNode internal_mic(kInternalMic);
1024   internal_mic.active = true;
1025   audio_nodes.push_back(internal_mic);
1026   audio_nodes.push_back(kUSBMic);
1027   ChangeAudioNodes(audio_nodes);
1028
1029   // Verify the AudioNodesChanged event is fired and new audio device is added.
1030   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
1031   cras_audio_handler_->GetAudioDevices(&audio_devices);
1032   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
1033
1034   // Verify the active input device is switched to USB mic and
1035   // and ActiveInputChanged event is fired.
1036   EXPECT_EQ(1, test_observer_->active_input_node_changed_count());
1037   EXPECT_EQ(kUSBMicId, cras_audio_handler_->GetActiveInputNode());
1038   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1039 }
1040
1041 TEST_F(CrasAudioHandlerTest, UnplugUSBMic) {
1042   // Set up initial audio devices, with internal mic and USB Mic.
1043   AudioNodeList audio_nodes;
1044   audio_nodes.push_back(kInternalMic);
1045   audio_nodes.push_back(kUSBMic);
1046   SetUpCrasAudioHandler(audio_nodes);
1047   const size_t init_nodes_size = audio_nodes.size();
1048
1049   // Verify the audio devices size.
1050   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
1051   AudioDeviceList audio_devices;
1052   cras_audio_handler_->GetAudioDevices(&audio_devices);
1053   EXPECT_EQ(init_nodes_size, audio_devices.size());
1054
1055   // Verify the USB mic is selected as the active output.
1056   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
1057   EXPECT_EQ(kUSBMicId, cras_audio_handler_->GetActiveInputNode());
1058   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1059
1060   // Unplug the USB Mic.
1061   audio_nodes.clear();
1062   audio_nodes.push_back(kInternalMic);
1063   ChangeAudioNodes(audio_nodes);
1064
1065   // Verify the AudioNodesChanged event is fired, and one audio device is
1066   // removed.
1067   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
1068   cras_audio_handler_->GetAudioDevices(&audio_devices);
1069   EXPECT_EQ(init_nodes_size - 1, audio_devices.size());
1070
1071   // Verify the active input device is switched to internal mic, and
1072   // and ActiveInputChanged event is fired.
1073   EXPECT_EQ(1, test_observer_->active_input_node_changed_count());
1074   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
1075   EXPECT_FALSE(cras_audio_handler_->has_alternative_input());
1076 }
1077
1078 TEST_F(CrasAudioHandlerTest, PlugUSBMicNotAffectActiveOutput) {
1079   // Set up initial audio devices.
1080   AudioNodeList audio_nodes;
1081   audio_nodes.push_back(kInternalSpeaker);
1082   audio_nodes.push_back(kHeadphone);
1083   audio_nodes.push_back(kInternalMic);
1084   SetUpCrasAudioHandler(audio_nodes);
1085   const size_t init_nodes_size = audio_nodes.size();
1086
1087   // Verify the audio devices size.
1088   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
1089   AudioDeviceList audio_devices;
1090   cras_audio_handler_->GetAudioDevices(&audio_devices);
1091   EXPECT_EQ(init_nodes_size, audio_devices.size());
1092
1093   // Verify the internal mic is selected as the active input.
1094   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
1095   EXPECT_EQ(kInternalMicId, cras_audio_handler_->GetActiveInputNode());
1096   EXPECT_FALSE(cras_audio_handler_->has_alternative_input());
1097
1098   // Verify the headphone is selected as the active output.
1099   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
1100   EXPECT_EQ(kHeadphoneId, cras_audio_handler_->GetActiveOutputNode());
1101   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1102
1103   // Switch the active output to internal speaker.
1104   AudioDevice internal_speaker(kInternalSpeaker);
1105   cras_audio_handler_->SwitchToDevice(internal_speaker);
1106
1107   // Verify the active output is switched to internal speaker, and the
1108   // ActiveOutputNodeChanged event is fired.
1109   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
1110   AudioDevice active_output;
1111   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
1112   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
1113   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
1114
1115   // Plug the USB Mic.
1116   audio_nodes.clear();
1117   AudioNode internal_speaker_node(kInternalSpeaker);
1118   internal_speaker_node.active = true;
1119   audio_nodes.push_back(internal_speaker_node);
1120   audio_nodes.push_back(kHeadphone);
1121   AudioNode internal_mic(kInternalMic);
1122   internal_mic.active = true;
1123   audio_nodes.push_back(internal_mic);
1124   audio_nodes.push_back(kUSBMic);
1125   ChangeAudioNodes(audio_nodes);
1126
1127   // Verify the AudioNodesChanged event is fired, one new device is added.
1128   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
1129   cras_audio_handler_->GetAudioDevices(&audio_devices);
1130   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
1131
1132   // Verify the active input device is switched to USB mic, and
1133   // and ActiveInputChanged event is fired.
1134   EXPECT_EQ(1, test_observer_->active_input_node_changed_count());
1135   EXPECT_EQ(kUSBMic.id, cras_audio_handler_->GetActiveInputNode());
1136   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1137
1138   // Verify the active output device is not changed.
1139   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
1140   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
1141   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
1142   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
1143 }
1144
1145 TEST_F(CrasAudioHandlerTest, PlugHeadphoneAutoUnplugSpeakerWithActiveUSB) {
1146   // Set up initial audio devices.
1147   AudioNodeList audio_nodes;
1148   audio_nodes.push_back(kUSBHeadphone1);
1149   audio_nodes.push_back(kInternalSpeaker);
1150   audio_nodes.push_back(kInternalMic);
1151   SetUpCrasAudioHandler(audio_nodes);
1152   const size_t init_nodes_size = audio_nodes.size();
1153
1154   // Verify the audio devices size.
1155   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
1156   AudioDeviceList audio_devices;
1157   cras_audio_handler_->GetAudioDevices(&audio_devices);
1158   EXPECT_EQ(init_nodes_size, audio_devices.size());
1159
1160   // Verify the internal mic is selected as the active input.
1161   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
1162   EXPECT_EQ(kInternalMicId, cras_audio_handler_->GetActiveInputNode());
1163   EXPECT_FALSE(cras_audio_handler_->has_alternative_input());
1164
1165   // Verify the USB headphone is selected as the active output.
1166   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
1167   EXPECT_EQ(kUSBHeadphoneId1, cras_audio_handler_->GetActiveOutputNode());
1168   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1169
1170   // Plug the headphone and auto-unplug internal speaker.
1171   audio_nodes.clear();
1172   AudioNode usb_headphone_node(kUSBHeadphone1);
1173   usb_headphone_node.active = true;
1174   audio_nodes.push_back(usb_headphone_node);
1175   AudioNode headphone_node(kHeadphone);
1176   headphone_node.plugged_time = 1000;
1177   audio_nodes.push_back(headphone_node);
1178   AudioNode internal_mic(kInternalMic);
1179   internal_mic.active = true;
1180   audio_nodes.push_back(internal_mic);
1181   ChangeAudioNodes(audio_nodes);
1182
1183   // Verify the AudioNodesChanged event is fired, with nodes count unchanged.
1184   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
1185   cras_audio_handler_->GetAudioDevices(&audio_devices);
1186   EXPECT_EQ(init_nodes_size, audio_devices.size());
1187
1188   // Verify the active output device is switched to headphone, and
1189   // an ActiveOutputChanged event is fired.
1190   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
1191   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
1192   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1193
1194   // Unplug the headphone and internal speaker auto-plugs back.
1195   audio_nodes.clear();
1196   audio_nodes.push_back(kUSBHeadphone1);
1197   AudioNode internal_speaker_node(kInternalSpeaker);
1198   internal_speaker_node.plugged_time = 2000;
1199   audio_nodes.push_back(internal_speaker_node);
1200   audio_nodes.push_back(internal_mic);
1201   ChangeAudioNodes(audio_nodes);
1202
1203   // Verify the AudioNodesChanged event is fired, with nodes count unchanged.
1204   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
1205   cras_audio_handler_->GetAudioDevices(&audio_devices);
1206   EXPECT_EQ(init_nodes_size, audio_devices.size());
1207
1208   // Verify the active output device is switched back to USB, and
1209   // an ActiveOutputChanged event is fired.
1210   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
1211   EXPECT_EQ(kUSBHeadphone1.id, cras_audio_handler_->GetActiveOutputNode());
1212   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1213
1214   // Verify the active input device is not changed.
1215   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
1216   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
1217 }
1218
1219 TEST_F(CrasAudioHandlerTest, PlugMicAutoUnplugInternalMicWithActiveUSB) {
1220   // Set up initial audio devices.
1221   AudioNodeList audio_nodes;
1222   audio_nodes.push_back(kUSBHeadphone1);
1223   audio_nodes.push_back(kInternalSpeaker);
1224   audio_nodes.push_back(kUSBMic);
1225   audio_nodes.push_back(kInternalMic);
1226   SetUpCrasAudioHandler(audio_nodes);
1227   const size_t init_nodes_size = audio_nodes.size();
1228
1229   // Verify the audio devices size.
1230   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
1231   AudioDeviceList audio_devices;
1232   cras_audio_handler_->GetAudioDevices(&audio_devices);
1233   EXPECT_EQ(init_nodes_size, audio_devices.size());
1234
1235   // Verify the internal mic is selected as the active input.
1236   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
1237   EXPECT_EQ(kUSBMicId, cras_audio_handler_->GetActiveInputNode());
1238   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1239
1240   // Verify the internal speaker is selected as the active output.
1241   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
1242   EXPECT_EQ(kUSBHeadphoneId1, cras_audio_handler_->GetActiveOutputNode());
1243   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1244
1245   // Plug the headphone and mic, auto-unplug internal mic and speaker.
1246   audio_nodes.clear();
1247   AudioNode usb_headphone_node(kUSBHeadphone1);
1248   usb_headphone_node.active = true;
1249   audio_nodes.push_back(usb_headphone_node);
1250   AudioNode headphone_node(kHeadphone);
1251   headphone_node.plugged_time = 1000;
1252   audio_nodes.push_back(headphone_node);
1253   AudioNode usb_mic(kUSBMic);
1254   usb_mic.active = true;
1255   audio_nodes.push_back(usb_mic);
1256   AudioNode mic_jack(kMicJack);
1257   mic_jack.plugged_time = 1000;
1258   audio_nodes.push_back(mic_jack);
1259   ChangeAudioNodes(audio_nodes);
1260
1261   // Verify the AudioNodesChanged event is fired, with nodes count unchanged.
1262   EXPECT_EQ(1, test_observer_->audio_nodes_changed_count());
1263   cras_audio_handler_->GetAudioDevices(&audio_devices);
1264   EXPECT_EQ(init_nodes_size, audio_devices.size());
1265
1266   // Verify the active output device is switched to headphone, and
1267   // an ActiveOutputChanged event is fired.
1268   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
1269   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
1270   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1271
1272   // Verify the active input device is switched to mic jack, and
1273   // an ActiveInputChanged event is fired.
1274   EXPECT_EQ(1, test_observer_->active_input_node_changed_count());
1275   EXPECT_EQ(kMicJack.id, cras_audio_handler_->GetActiveInputNode());
1276   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1277
1278   // Unplug the headphone and internal speaker auto-plugs back.
1279   audio_nodes.clear();
1280   audio_nodes.push_back(kUSBHeadphone1);
1281   AudioNode internal_speaker_node(kInternalSpeaker);
1282   internal_speaker_node.plugged_time = 2000;
1283   audio_nodes.push_back(internal_speaker_node);
1284   audio_nodes.push_back(kUSBMic);
1285   AudioNode internal_mic(kInternalMic);
1286   internal_mic.plugged_time = 2000;
1287   audio_nodes.push_back(internal_mic);
1288   ChangeAudioNodes(audio_nodes);
1289
1290   // Verify the AudioNodesChanged event is fired, with nodes count unchanged.
1291   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
1292   cras_audio_handler_->GetAudioDevices(&audio_devices);
1293   EXPECT_EQ(init_nodes_size, audio_devices.size());
1294
1295   // Verify the active output device is switched back to USB, and
1296   // an ActiveOutputChanged event is fired.
1297   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
1298   EXPECT_EQ(kUSBHeadphone1.id, cras_audio_handler_->GetActiveOutputNode());
1299   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1300
1301   // Verify the active input device is switched back to USB mic, and
1302   // an ActiveInputChanged event is fired.
1303   EXPECT_EQ(2, test_observer_->active_input_node_changed_count());
1304   EXPECT_EQ(kUSBMic.id, cras_audio_handler_->GetActiveInputNode());
1305   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1306 }
1307
1308 TEST_F(CrasAudioHandlerTest, MultipleNodesChangedSignalsOnPlugInHeadphone) {
1309   // Set up initial audio devices.
1310   AudioNodeList audio_nodes;
1311   audio_nodes.push_back(kInternalSpeaker);
1312   audio_nodes.push_back(kBluetoothHeadset);
1313   SetUpCrasAudioHandler(audio_nodes);
1314   const size_t init_nodes_size = audio_nodes.size();
1315
1316   // Verify the audio devices size.
1317   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
1318   AudioDeviceList audio_devices;
1319   cras_audio_handler_->GetAudioDevices(&audio_devices);
1320   EXPECT_EQ(init_nodes_size, audio_devices.size());
1321
1322   // Verify the bluetooth headset is selected as the active output.
1323   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
1324   EXPECT_EQ(kBluetoothHeadsetId, cras_audio_handler_->GetActiveOutputNode());
1325   AudioDevice active_output;
1326   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
1327   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1328
1329   // Plug in headphone, but fire NodesChanged signal twice.
1330   audio_nodes.clear();
1331   audio_nodes.push_back(kInternalSpeaker);
1332   AudioNode bluetooth_headset(kBluetoothHeadset);
1333   bluetooth_headset.plugged_time = 1000;
1334   bluetooth_headset.active = true;
1335   audio_nodes.push_back(bluetooth_headset);
1336   AudioNode headphone(kHeadphone);
1337   headphone.active = false;
1338   headphone.plugged_time = 2000;
1339   audio_nodes.push_back(headphone);
1340   ChangeAudioNodes(audio_nodes);
1341   ChangeAudioNodes(audio_nodes);
1342
1343   // Verify the active output device is set to headphone.
1344   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
1345   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
1346   EXPECT_EQ(headphone.id, cras_audio_handler_->GetActiveOutputNode());
1347   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
1348   EXPECT_EQ(headphone.id, active_output.id);
1349
1350   // Verfiy the audio devices data is consistent, i.e., the active output device
1351   // should be headphone.
1352   cras_audio_handler_->GetAudioDevices(&audio_devices);
1353   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
1354   for (size_t i = 0; i < audio_devices.size(); ++i) {
1355     if (audio_devices[i].id == kInternalSpeaker.id)
1356       EXPECT_FALSE(audio_devices[i].active);
1357     else if (audio_devices[i].id == bluetooth_headset.id)
1358       EXPECT_FALSE(audio_devices[i].active);
1359     else if (audio_devices[i].id == headphone.id)
1360       EXPECT_TRUE(audio_devices[i].active);
1361     else
1362       NOTREACHED();
1363   }
1364 }
1365
1366 TEST_F(CrasAudioHandlerTest, MultipleNodesChangedSignalsOnPlugInUSBMic) {
1367   // Set up initial audio devices.
1368   AudioNodeList audio_nodes;
1369   audio_nodes.push_back(kInternalMic);
1370   SetUpCrasAudioHandler(audio_nodes);
1371   const size_t init_nodes_size = audio_nodes.size();
1372
1373   // Verify the audio devices size.
1374   EXPECT_EQ(0, test_observer_->audio_nodes_changed_count());
1375   AudioDeviceList audio_devices;
1376   cras_audio_handler_->GetAudioDevices(&audio_devices);
1377   EXPECT_EQ(init_nodes_size, audio_devices.size());
1378
1379   // Verify the internal mic is selected as the active output.
1380   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
1381   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
1382   EXPECT_FALSE(cras_audio_handler_->has_alternative_output());
1383   EXPECT_TRUE(audio_devices[0].active);
1384
1385   // Plug in usb mic, but fire NodesChanged signal twice.
1386   audio_nodes.clear();
1387   AudioNode internal_mic(kInternalMic);
1388   internal_mic.active = true;
1389   internal_mic.plugged_time = 1000;
1390   audio_nodes.push_back(internal_mic);
1391   AudioNode usb_mic(kUSBMic);
1392   usb_mic.active = false;
1393   usb_mic.plugged_time = 2000;
1394   audio_nodes.push_back(usb_mic);
1395   ChangeAudioNodes(audio_nodes);
1396   ChangeAudioNodes(audio_nodes);
1397
1398   // Verify the active output device is set to headphone.
1399   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
1400   EXPECT_EQ(1, test_observer_->active_input_node_changed_count());
1401   EXPECT_EQ(usb_mic.id, cras_audio_handler_->GetActiveInputNode());
1402   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1403
1404   // Verfiy the audio devices data is consistent, i.e., the active input device
1405   // should be usb mic.
1406   cras_audio_handler_->GetAudioDevices(&audio_devices);
1407   EXPECT_EQ(init_nodes_size + 1, audio_devices.size());
1408   for (size_t i = 0; i < audio_devices.size(); ++i) {
1409     if (audio_devices[i].id == kInternalMic.id)
1410       EXPECT_FALSE(audio_devices[i].active);
1411     else if (audio_devices[i].id == usb_mic.id)
1412       EXPECT_TRUE(audio_devices[i].active);
1413     else
1414       NOTREACHED();
1415   }
1416 }
1417
1418 // This is the case of crbug.com/291303.
1419 TEST_F(CrasAudioHandlerTest, MultipleNodesChangedSignalsOnSystemBoot) {
1420   // Set up audio handler with empty audio_nodes.
1421   AudioNodeList audio_nodes;
1422   SetUpCrasAudioHandler(audio_nodes);
1423
1424   AudioNode internal_speaker(kInternalSpeaker);
1425   internal_speaker.active = false;
1426   AudioNode headphone(kHeadphone);
1427   headphone.active = false;
1428   AudioNode internal_mic(kInternalMic);
1429   internal_mic.active = false;
1430   audio_nodes.push_back(internal_speaker);
1431   audio_nodes.push_back(headphone);
1432   audio_nodes.push_back(internal_mic);
1433   const size_t init_nodes_size = audio_nodes.size();
1434
1435   // Simulate AudioNodesChanged signal being fired twice during system boot.
1436   ChangeAudioNodes(audio_nodes);
1437   ChangeAudioNodes(audio_nodes);
1438
1439   // Verify the active output device is set to headphone.
1440   EXPECT_EQ(2, test_observer_->audio_nodes_changed_count());
1441   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
1442   EXPECT_EQ(headphone.id, cras_audio_handler_->GetActiveOutputNode());
1443   AudioDevice active_output;
1444   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
1445   EXPECT_EQ(headphone.id, active_output.id);
1446
1447   // Verify the active input device id is set to internal mic.
1448   EXPECT_EQ(internal_mic.id, cras_audio_handler_->GetActiveInputNode());
1449
1450   // Verfiy the audio devices data is consistent, i.e., the active output device
1451   // should be headphone, and the active input device should internal mic.
1452   AudioDeviceList audio_devices;
1453   cras_audio_handler_->GetAudioDevices(&audio_devices);
1454   EXPECT_EQ(init_nodes_size, audio_devices.size());
1455   for (size_t i = 0; i < audio_devices.size(); ++i) {
1456     if (audio_devices[i].id == internal_speaker.id)
1457       EXPECT_FALSE(audio_devices[i].active);
1458     else if (audio_devices[i].id == headphone.id)
1459       EXPECT_TRUE(audio_devices[i].active);
1460     else if (audio_devices[i].id == internal_mic.id)
1461       EXPECT_TRUE(audio_devices[i].active);
1462     else
1463       NOTREACHED();
1464   }
1465 }
1466
1467 TEST_F(CrasAudioHandlerTest, SetOutputMute) {
1468   AudioNodeList audio_nodes;
1469   audio_nodes.push_back(kInternalSpeaker);
1470   SetUpCrasAudioHandler(audio_nodes);
1471   EXPECT_EQ(0, test_observer_->output_mute_changed_count());
1472
1473   // Mute the device.
1474   cras_audio_handler_->SetOutputMute(true);
1475
1476   // Verify the output is muted, OnOutputMuteChanged event is fired,
1477   // and mute value is saved in the preferences.
1478   EXPECT_TRUE(cras_audio_handler_->IsOutputMuted());
1479   EXPECT_EQ(1, test_observer_->output_mute_changed_count());
1480   AudioDevice speaker(kInternalSpeaker);
1481   EXPECT_TRUE(audio_pref_handler_->GetMuteValue(speaker));
1482
1483   // Unmute the device.
1484   cras_audio_handler_->SetOutputMute(false);
1485
1486   // Verify the output is unmuted, OnOutputMuteChanged event is fired,
1487   // and mute value is saved in the preferences.
1488   EXPECT_FALSE(cras_audio_handler_->IsOutputMuted());
1489   EXPECT_EQ(2, test_observer_->output_mute_changed_count());
1490   EXPECT_FALSE(audio_pref_handler_->GetMuteValue(speaker));
1491 }
1492
1493 TEST_F(CrasAudioHandlerTest, SetInputMute) {
1494   AudioNodeList audio_nodes;
1495   audio_nodes.push_back(kInternalMic);
1496   SetUpCrasAudioHandler(audio_nodes);
1497   EXPECT_EQ(0, test_observer_->input_mute_changed_count());
1498
1499   // Mute the device.
1500   cras_audio_handler_->SetInputMute(true);
1501
1502   // Verify the input is muted, OnInputMuteChanged event is fired.
1503   EXPECT_TRUE(cras_audio_handler_->IsInputMuted());
1504   EXPECT_EQ(1, test_observer_->input_mute_changed_count());
1505
1506   // Unmute the device.
1507   cras_audio_handler_->SetInputMute(false);
1508
1509   // Verify the input is unmuted, OnInputMuteChanged event is fired.
1510   EXPECT_FALSE(cras_audio_handler_->IsInputMuted());
1511   EXPECT_EQ(2, test_observer_->input_mute_changed_count());
1512 }
1513
1514 TEST_F(CrasAudioHandlerTest, SetOutputVolumePercent) {
1515   AudioNodeList audio_nodes;
1516   audio_nodes.push_back(kInternalSpeaker);
1517   SetUpCrasAudioHandler(audio_nodes);
1518   EXPECT_EQ(0, test_observer_->output_volume_changed_count());
1519
1520   cras_audio_handler_->SetOutputVolumePercent(60);
1521
1522   // Verify the output volume is changed to the designated value,
1523   // OnOutputVolumeChanged event is fired, and the device volume value
1524   // is saved the preferences.
1525   const int kVolume = 60;
1526   EXPECT_EQ(kVolume, cras_audio_handler_->GetOutputVolumePercent());
1527   EXPECT_EQ(1, test_observer_->output_volume_changed_count());
1528   AudioDevice device;
1529   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&device));
1530   EXPECT_EQ(device.id, kInternalSpeaker.id);
1531   EXPECT_EQ(kVolume, audio_pref_handler_->GetOutputVolumeValue(&device));
1532 }
1533
1534 TEST_F(CrasAudioHandlerTest, SetInputGainPercent) {
1535   AudioNodeList audio_nodes;
1536   audio_nodes.push_back(kInternalMic);
1537   SetUpCrasAudioHandler(audio_nodes);
1538   EXPECT_EQ(0, test_observer_->input_gain_changed_count());
1539
1540   cras_audio_handler_->SetInputGainPercent(60);
1541
1542   // Verify the input gain changed to the designated value,
1543   // OnInputGainChanged event is fired, and the device gain value
1544   // is saved in the preferences.
1545   const int kGain = 60;
1546   EXPECT_EQ(kGain, cras_audio_handler_->GetInputGainPercent());
1547   EXPECT_EQ(1, test_observer_->input_gain_changed_count());
1548   AudioDevice internal_mic(kInternalMic);
1549   EXPECT_EQ(kGain, audio_pref_handler_->GetInputGainValue(&internal_mic));
1550 }
1551
1552 TEST_F(CrasAudioHandlerTest, SetMuteForDevice) {
1553   AudioNodeList audio_nodes;
1554   audio_nodes.push_back(kInternalSpeaker);
1555   audio_nodes.push_back(kHeadphone);
1556   audio_nodes.push_back(kInternalMic);
1557   audio_nodes.push_back(kUSBMic);
1558   SetUpCrasAudioHandler(audio_nodes);
1559
1560   // Mute the active output device.
1561   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
1562   cras_audio_handler_->SetMuteForDevice(kHeadphone.id, true);
1563
1564   // Verify the headphone is muted and mute value is saved in the preferences.
1565   EXPECT_TRUE(cras_audio_handler_->IsOutputMutedForDevice(kHeadphone.id));
1566   AudioDevice headphone(kHeadphone);
1567   EXPECT_TRUE(audio_pref_handler_->GetMuteValue(headphone));
1568
1569   // Mute the non-active output device.
1570   cras_audio_handler_->SetMuteForDevice(kInternalSpeaker.id, true);
1571
1572   // Verify the internal speaker is muted and mute value is saved in the
1573   // preferences.
1574   EXPECT_TRUE(cras_audio_handler_->IsOutputMutedForDevice(kInternalSpeaker.id));
1575   AudioDevice internal_speaker(kInternalSpeaker);
1576   EXPECT_TRUE(audio_pref_handler_->GetMuteValue(internal_speaker));
1577
1578   // Mute the active input device.
1579   EXPECT_EQ(kUSBMic.id, cras_audio_handler_->GetActiveInputNode());
1580   cras_audio_handler_->SetMuteForDevice(kUSBMic.id, true);
1581
1582   // Verify the USB Mic is muted.
1583   EXPECT_TRUE(cras_audio_handler_->IsInputMutedForDevice(kUSBMic.id));
1584
1585   // Mute the non-active input device should be a no-op, see crbug.com/365050.
1586   cras_audio_handler_->SetMuteForDevice(kInternalMic.id, true);
1587
1588   // Verify IsInputMutedForDevice returns false for non-active input device.
1589   EXPECT_FALSE(cras_audio_handler_->IsInputMutedForDevice(kInternalMic.id));
1590 }
1591
1592 TEST_F(CrasAudioHandlerTest, SetVolumeGainPercentForDevice) {
1593   AudioNodeList audio_nodes;
1594   audio_nodes.push_back(kInternalSpeaker);
1595   audio_nodes.push_back(kHeadphone);
1596   audio_nodes.push_back(kInternalMic);
1597   audio_nodes.push_back(kUSBMic);
1598   SetUpCrasAudioHandler(audio_nodes);
1599
1600   // Set volume percent for active output device.
1601   const int kHeadphoneVolume = 30;
1602   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
1603   cras_audio_handler_->SetVolumeGainPercentForDevice(kHeadphone.id,
1604                                                      kHeadphoneVolume);
1605
1606   // Verify the volume percent of headphone is set, and saved in preferences.
1607   EXPECT_EQ(kHeadphoneVolume,
1608             cras_audio_handler_->GetOutputVolumePercentForDevice(
1609                 kHeadphone.id));
1610   AudioDevice headphone(kHeadphone);
1611   EXPECT_EQ(kHeadphoneVolume,
1612             audio_pref_handler_->GetOutputVolumeValue(&headphone));
1613
1614   // Set volume percent for non-active output device.
1615   const int kSpeakerVolume = 60;
1616   cras_audio_handler_->SetVolumeGainPercentForDevice(kInternalSpeaker.id,
1617                                                      kSpeakerVolume);
1618
1619   // Verify the volume percent of speaker is set, and saved in preferences.
1620   EXPECT_EQ(kSpeakerVolume,
1621             cras_audio_handler_->GetOutputVolumePercentForDevice(
1622                 kInternalSpeaker.id));
1623   AudioDevice speaker(kInternalSpeaker);
1624   EXPECT_EQ(kSpeakerVolume,
1625             audio_pref_handler_->GetOutputVolumeValue(&speaker));
1626
1627   // Set gain percent for active input device.
1628   const int kUSBMicGain = 30;
1629   EXPECT_EQ(kUSBMic.id, cras_audio_handler_->GetActiveInputNode());
1630   cras_audio_handler_->SetVolumeGainPercentForDevice(kUSBMic.id,
1631                                                      kUSBMicGain);
1632
1633   // Verify the gain percent of USB mic is set, and saved in preferences.
1634   EXPECT_EQ(kUSBMicGain,
1635             cras_audio_handler_->GetOutputVolumePercentForDevice(kUSBMic.id));
1636   AudioDevice usb_mic(kHeadphone);
1637   EXPECT_EQ(kUSBMicGain,
1638             audio_pref_handler_->GetInputGainValue(&usb_mic));
1639
1640   // Set gain percent for non-active input device.
1641   const int kInternalMicGain = 60;
1642   cras_audio_handler_->SetVolumeGainPercentForDevice(kInternalMic.id,
1643                                                      kInternalMicGain);
1644
1645   // Verify the gain percent of internal mic is set, and saved in preferences.
1646   EXPECT_EQ(kInternalMicGain,
1647             cras_audio_handler_->GetOutputVolumePercentForDevice(
1648                 kInternalMic.id));
1649   AudioDevice internal_mic(kInternalMic);
1650   EXPECT_EQ(kInternalMicGain,
1651             audio_pref_handler_->GetInputGainValue(&internal_mic));
1652 }
1653
1654 TEST_F(CrasAudioHandlerTest, HandleOtherDeviceType) {
1655   const size_t kNumValidAudioDevices = 4;
1656   AudioNodeList audio_nodes;
1657   audio_nodes.push_back(kInternalSpeaker);
1658   audio_nodes.push_back(kOtherTypeOutput);
1659   audio_nodes.push_back(kInternalMic);
1660   audio_nodes.push_back(kOtherTypeInput);
1661   SetUpCrasAudioHandler(audio_nodes);
1662
1663   // Verify the audio devices size.
1664   AudioDeviceList audio_devices;
1665   cras_audio_handler_->GetAudioDevices(&audio_devices);
1666   EXPECT_EQ(kNumValidAudioDevices, audio_devices.size());
1667
1668   // Verify the internal speaker has been selected as the active output,
1669   // and the output device with some randown unknown type is handled gracefully.
1670   AudioDevice active_output;
1671   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&active_output));
1672   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
1673   EXPECT_EQ(kInternalSpeaker.id, cras_audio_handler_->GetActiveOutputNode());
1674   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
1675
1676   // Ensure the internal microphone has been selected as the active input,
1677   // and the input device with some random unknown type is handled gracefully.
1678   AudioDevice active_input;
1679   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
1680   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
1681 }
1682
1683 }  // namespace chromeos