Persist the user's active audio device choice across chromeos session and reboots.

chromeos/audio/cras_audio_handler_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/audio/cras_audio_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
+#include "chromeos/audio/audio_devices_pref_handler.h"
 #include "chromeos/audio/audio_devices_pref_handler_stub.h"
 #include "chromeos/dbus/audio_node.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cras_audio_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace {
 
 const uint64_t kInternalSpeakerId = 10001;
@@ skipping 289 matching lines @@
         DBusThreadManager::Get()->GetCrasAudioClient());
     fake_cras_audio_client_->SetAudioNodesForTesting(audio_nodes);
     audio_pref_handler_ = new AudioDevicesPrefHandlerStub();
     CrasAudioHandler::Initialize(audio_pref_handler_);
     cras_audio_handler_ = CrasAudioHandler::Get();
     test_observer_.reset(new TestObserver);
     cras_audio_handler_->AddAudioObserver(test_observer_.get());
     message_loop_.RunUntilIdle();
   }
 
+  // Set up cras audio handlers with |audio_nodes| and set the active state of
+  // |active_device_in_pref| as active and |activate_by_user| in the pref,
+  // and rest of nodes in |audio_nodes_in_pref| as inactive.
+  void SetupCrasAudioHandlerWithActiveNodeInPref(
+      const AudioNodeList& audio_nodes,
+      const AudioNodeList& audio_nodes_in_pref,
+      const AudioDevice& active_device_in_pref,
+      bool activate_by_user) {
+    DBusThreadManager::Initialize();
+    fake_cras_audio_client_ = static_cast<FakeCrasAudioClient*>(
+        DBusThreadManager::Get()->GetCrasAudioClient());
+    audio_pref_handler_ = new AudioDevicesPrefHandlerStub();
+    bool active;
+    for (const AudioNode& node : audio_nodes_in_pref) {
+      active = node.id == active_device_in_pref.id;
+      audio_pref_handler_->SetDeviceActive(AudioDevice(node), active,
+                                           activate_by_user);
+    }
+
+    bool activate_by;
+    EXPECT_TRUE(audio_pref_handler_->GetDeviceActive(active_device_in_pref,
+                                                     &active, &activate_by));
+    EXPECT_TRUE(active);
+    EXPECT_EQ(activate_by, activate_by_user);
+
+    fake_cras_audio_client_->SetAudioNodesForTesting(audio_nodes);
+    CrasAudioHandler::Initialize(audio_pref_handler_);
+
+    cras_audio_handler_ = CrasAudioHandler::Get();
+    test_observer_.reset(new TestObserver);
+    cras_audio_handler_->AddAudioObserver(test_observer_.get());
+    message_loop_.RunUntilIdle();
+  }
+
   void SetUpCrasAudioHandlerWithPrimaryActiveNode(
       const AudioNodeList& audio_nodes,
       const AudioNode& primary_active_node) {
     DBusThreadManager::Initialize();
     fake_cras_audio_client_ = static_cast<FakeCrasAudioClient*>(
         DBusThreadManager::Get()->GetCrasAudioClient());
     fake_cras_audio_client_->SetAudioNodesForTesting(audio_nodes);
     fake_cras_audio_client_->SetActiveOutputNode(primary_active_node.id),
         audio_pref_handler_ = new AudioDevicesPrefHandlerStub();
     CrasAudioHandler::Initialize(audio_pref_handler_);
@@ skipping 215 matching lines @@
   // Verify the initial active output device is headphone.
   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
   AudioDevice active_output;
   EXPECT_TRUE(
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(kHeadphone.id, active_output.id);
   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
 
   // Switch the active output to internal speaker.
   AudioDevice internal_speaker(kInternalSpeaker);
-  cras_audio_handler_->SwitchToDevice(internal_speaker, true);
+  cras_audio_handler_->SwitchToDevice(internal_speaker, true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
 
   // Verify the active output is switched to internal speaker, and the
   // ActiveOutputNodeChanged event is fired.
   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
   EXPECT_TRUE(
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
   EXPECT_EQ(kInternalSpeaker.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
 }
 
 TEST_F(CrasAudioHandlerTest, SwitchActiveInputDevice) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalMic);
   audio_nodes.push_back(kUSBMic);
   SetUpCrasAudioHandler(audio_nodes);
   AudioDeviceList audio_devices;
   cras_audio_handler_->GetAudioDevices(&audio_devices);
   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 
   // Verify the initial active input device is USB mic.
   EXPECT_EQ(0, test_observer_->active_input_node_changed_count());
   EXPECT_EQ(kUSBMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
 
   // Switch the active input to internal mic.
   AudioDevice internal_mic(kInternalMic);
-  cras_audio_handler_->SwitchToDevice(internal_mic, true);
+  cras_audio_handler_->SwitchToDevice(internal_mic, true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
 
   // Verify the active output is switched to internal speaker, and the active
   // ActiveInputNodeChanged event is fired.
   EXPECT_EQ(1, test_observer_->active_input_node_changed_count());
   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetPrimaryActiveInputNode());
 }
 
 TEST_F(CrasAudioHandlerTest, PlugHeadphone) {
   // Set up initial audio devices, only with internal speaker.
   AudioNodeList audio_nodes;
@@ skipping 533 matching lines @@
   // is plugged later, and ActiveOutputChanged event is fired.
   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
   EXPECT_TRUE(
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(kHeadphone.id, active_output.id);
   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 
   // Select the speaker to be the active output device.
   AudioDevice internal_speaker(kInternalSpeaker);
-  cras_audio_handler_->SwitchToDevice(internal_speaker, true);
+  cras_audio_handler_->SwitchToDevice(internal_speaker, true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
 
   // Verify the active output is switched to internal speaker, and the
   // ActiveOutputNodeChanged event is fired.
   EXPECT_EQ(2, test_observer_->active_output_node_changed_count());
   EXPECT_TRUE(
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
   EXPECT_EQ(kInternalSpeaker.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
 
@@ skipping 210 matching lines @@
   EXPECT_EQ(kInternalMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
   EXPECT_FALSE(cras_audio_handler_->has_alternative_input());
 
   // Verify the headphone is selected as the active output.
   EXPECT_EQ(0, test_observer_->active_output_node_changed_count());
   EXPECT_EQ(kHeadphoneId, cras_audio_handler_->GetPrimaryActiveOutputNode());
   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 
   // Switch the active output to internal speaker.
   AudioDevice internal_speaker(kInternalSpeaker);
-  cras_audio_handler_->SwitchToDevice(internal_speaker, true);
+  cras_audio_handler_->SwitchToDevice(internal_speaker, true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
 
   // Verify the active output is switched to internal speaker, and the
   // ActiveOutputNodeChanged event is fired.
   EXPECT_EQ(1, test_observer_->active_output_node_changed_count());
   AudioDevice active_output;
   EXPECT_TRUE(
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
   EXPECT_EQ(kInternalSpeaker.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
@@ skipping 674 matching lines @@
   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 
   // Initially active node is selected base on priority, so USB headphone
   // is selected.
   EXPECT_EQ(kUSBHeadphone1.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
 
   // Change the active device to internal speaker, now USB headphone becomes
   // inactive.
   AudioDevice speaker(kInternalSpeaker);
-  cras_audio_handler_->SwitchToDevice(speaker, true);
+  cras_audio_handler_->SwitchToDevice(speaker, true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
   EXPECT_NE(kUSBHeadphone1.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
 
   // Unplug USB headset.
   audio_nodes.clear();
   internal_speaker.active = true;
   audio_nodes.push_back(internal_speaker);
   ChangeAudioNodes(audio_nodes);
   EXPECT_EQ(kInternalSpeaker.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
@@ skipping 25 matching lines @@
   audio_nodes.clear();
   internal_speaker.active = false;
   audio_nodes.push_back(internal_speaker);
   audio_nodes.push_back(usb_headset);
   ChangeAudioNodes(audio_nodes);
 
   // There is no active node after USB2 unplugged, the 1st USB got selected
   // by its priority.
   EXPECT_EQ(usb_headset.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
 
+  audio_nodes.clear();
+  internal_speaker.active = false;
+  audio_nodes.push_back(internal_speaker);
+  usb_headset.active = true;
+  audio_nodes.push_back(usb_headset);
   usb_headset2.active = false;
   usb_headset2.plugged_time = 80000002;
   audio_nodes.push_back(usb_headset2);
   ChangeAudioNodes(audio_nodes);
 
   // Plug the second USB again. Since it was the active node before it got
   // unplugged, it is now selected as the active node.
   EXPECT_EQ(usb_headset2.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
 }
 
+// Test the device new session case, either via reboot or logout, if there
+// is an active device in the previous session, that device should still
+// be set as active after the new session starts.
+TEST_F(CrasAudioHandlerTest, PersistActiveDeviceAcrossSession) {
+  // Set the active device to internal speaker before the session starts.
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kHeadphone);
+  SetupCrasAudioHandlerWithActiveNodeInPref(
+      audio_nodes, audio_nodes, AudioDevice(kInternalSpeaker), true);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the active device is the internal speaker, which is of a lower
+  // priority, but selected as active since it was the active device previously.
+  EXPECT_EQ(kInternalSpeaker.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+}
+
+TEST_F(CrasAudioHandlerTest, PersistActiveSpeakerAcrossReboot) {
+  // Simulates the device was shut down with three audio devices, and
+  // internal speaker being the active one selected by user.
+  AudioNodeList audio_nodes_in_pref;
+  audio_nodes_in_pref.push_back(kInternalSpeaker);
+  audio_nodes_in_pref.push_back(kHeadphone);
+  audio_nodes_in_pref.push_back(kUSBHeadphone1);
+
+  // Simulate the first NodesChanged signal coming with only one node.
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kUSBHeadphone1);
+
+  SetupCrasAudioHandlerWithActiveNodeInPref(
+      audio_nodes, audio_nodes_in_pref, AudioDevice(kInternalSpeaker), true);
+
+  // Verify the usb headphone has been made active.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kUSBHeadphone1.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+
+  // Simulate another NodesChanged signal coming later with all ndoes.
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kHeadphone);
+  ChangeAudioNodes(audio_nodes);
+
+  // Verify the active output has been restored to internal speaker.
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kInternalSpeaker.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+}
+
+TEST_F(CrasAudioHandlerTest,
+       PersistActiveUsbHeadphoneAcrossRebootUsbComeLater) {
+  // Simulates the device was shut down with three audio devices, and
+  // usb headphone being the active one selected by priority.
+  AudioNodeList audio_nodes_in_pref;
+  audio_nodes_in_pref.push_back(kInternalSpeaker);
+  audio_nodes_in_pref.push_back(kHeadphone);
+  audio_nodes_in_pref.push_back(kUSBHeadphone1);
+
+  // Simulate the first NodesChanged signal coming with only internal speaker
+  // and the headphone.
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kHeadphone);
+
+  SetupCrasAudioHandlerWithActiveNodeInPref(audio_nodes, audio_nodes_in_pref,
+                                            AudioDevice(kUSBHeadphone1), false);
+
+  // Verify the headphone has been made active.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
+
+  // Simulate USB node comes later with all ndoes.
+  AudioNode usb_node(kUSBHeadphone1);
+  usb_node.plugged_time = 80000000;
+  audio_nodes.push_back(usb_node);
+  ChangeAudioNodes(audio_nodes);
+
+  // Verify the active output has been restored to usb headphone.
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kUSBHeadphone1.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+}
+
+TEST_F(CrasAudioHandlerTest,
+       PersistActiveUsbHeadphoneAcrossRebootUsbComeFirst) {
+  // Simulates the device was shut down with three audio devices, and
+  // usb headphone being the active one selected by priority.
+  AudioNodeList audio_nodes_in_pref;
+  audio_nodes_in_pref.push_back(kInternalSpeaker);
+  audio_nodes_in_pref.push_back(kHeadphone);
+  audio_nodes_in_pref.push_back(kUSBHeadphone1);
+
+  // Simulate the first NodesChanged signal coming with only internal speaker
+  // and the USB headphone.
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kUSBHeadphone1);
+
+  SetupCrasAudioHandlerWithActiveNodeInPref(audio_nodes, audio_nodes_in_pref,
+                                            AudioDevice(kUSBHeadphone1), false);
+
+  // Verify the USB headphone has been made active.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kUSBHeadphone1.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+
+  // Simulate another NodesChanged signal coming later with all ndoes.
+  AudioNode headphone_node(kHeadphone);
+  headphone_node.plugged_time = 80000000;
+  audio_nodes.push_back(headphone_node);
+  ChangeAudioNodes(audio_nodes);
+
+  // Verify the active output has been restored to USB headphone.
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kUSBHeadphone1.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+}
+
+// This covers the crbug.com/586026. Cras lost the active state of the internal
+// speaker when user unplugs the headphone, which is a bug in cras. However,
+// chrome code is still resilient and set the internal speaker back to active.
+TEST_F(CrasAudioHandlerTest, UnplugHeadphoneLostActiveInternalSpeakerByCras) {
+  // Set up with three nodes.
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kHeadphone);
+  audio_nodes.push_back(kUSBHeadphone1);
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Switch the active output to internal speaker.
+  cras_audio_handler_->SwitchToDevice(AudioDevice(kInternalSpeaker), true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
+
+  // Verify internal speaker has been made active.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kInternalSpeaker.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+
+  // Simulate unplug the headphone. Cras sends NodesChanged signal with
+  // both internal speaker and usb headphone being inactive.
+  audio_nodes.clear();
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kUSBHeadphone1);
+  EXPECT_FALSE(kInternalSpeaker.active);
+  EXPECT_FALSE(kUSBHeadphone1.active);
+  ChangeAudioNodes(audio_nodes);
+
+  // Verify the active output is set back to internal speaker.
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kInternalSpeaker.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+}
+
+TEST_F(CrasAudioHandlerTest, RemoveNonActiveDevice) {
+  // Set up with three nodes.
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kHeadphone);
+  audio_nodes.push_back(kUSBHeadphone1);
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Switch the active output to internal speaker.
+  cras_audio_handler_->SwitchToDevice(AudioDevice(kInternalSpeaker), true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
+
+  // Verify internal speaker has been made active.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kInternalSpeaker.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+
+  // Remove headphone, which is an non-active device.
+  audio_nodes.clear();
+  AudioNode speaker(kInternalSpeaker);
+  speaker.active = true;
+  audio_nodes.push_back(speaker);
+  AudioNode usb_headphone(kUSBHeadphone1);
+  usb_headphone.active = false;
+  audio_nodes.push_back(usb_headphone);
+
+  ChangeAudioNodes(audio_nodes);
+
+  // Verify the active output remains as internal speaker.
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+  EXPECT_EQ(kInternalSpeaker.id,
+            cras_audio_handler_->GetPrimaryActiveOutputNode());
+}
+
 TEST_F(CrasAudioHandlerTest, ChangeActiveNodesHotrodInit) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kHDMIOutput);
   audio_nodes.push_back(kUSBJabraSpeakerOutput1);
   audio_nodes.push_back(kUSBJabraSpeakerOutput2);
   audio_nodes.push_back(kUSBJabraSpeakerInput1);
   audio_nodes.push_back(kUSBJabraSpeakerInput2);
   audio_nodes.push_back(kUSBCameraInput);
   SetUpCrasAudioHandler(audio_nodes);
 
@@ skipping 410 matching lines @@
   // Verify the audio devices size.
   AudioDeviceList audio_devices;
   cras_audio_handler_->GetAudioDevices(&audio_devices);
   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
 
   // Verify the USB headset is selected as active output by default.
   EXPECT_EQ(usb_headset.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
 
   // Manually set the active output to internal speaker.
   AudioDevice internal_output(kInternalSpeaker);
-  cras_audio_handler_->SwitchToDevice(internal_output, true);
+  cras_audio_handler_->SwitchToDevice(internal_output, true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
 
   // Verify the active output is switched to internal speaker.
   EXPECT_EQ(internal_speaker.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
   EXPECT_LT(kInternalSpeaker.plugged_time, usb_headset.plugged_time);
   const AudioDevice* usb_device = GetDeviceFromId(usb_headset.id);
   EXPECT_FALSE(usb_device->active);
 
   // Plug in HDMI output.
   audio_nodes.clear();
@@ skipping 58 matching lines @@
   SetUpCrasAudioHandler(audio_nodes);
 
   // Verify the hdmi is selected as the active output since it has a higher
   // priority.
   AudioDeviceList audio_devices;
   cras_audio_handler_->GetAudioDevices(&audio_devices);
   EXPECT_EQ(audio_nodes.size(), audio_devices.size());
   EXPECT_EQ(hdmi_output.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
 
   // Manually set the active output to internal speaker.
-  cras_audio_handler_->SwitchToDevice(AudioDevice(internal_speaker), true);
+  cras_audio_handler_->SwitchToDevice(AudioDevice(internal_speaker), true,
+                                      CrasAudioHandler::ACTIVATE_BY_USER);
   EXPECT_EQ(internal_speaker.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
 
   // Simulate the suspend and resume of the device during mirror mode. The HDMI
   // node will be lost first.
   audio_nodes.clear();
   internal_speaker.active = true;
   audio_nodes.push_back(internal_speaker);
   ChangeAudioNodes(audio_nodes);
 
@@ skipping 147 matching lines @@
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(kInternalSpeaker.id, active_output.id);
   EXPECT_EQ(kInternalSpeaker.id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
   EXPECT_FALSE(cras_audio_handler_->IsOutputMuted());
   EXPECT_EQ(1, test_observer_->output_mute_changed_count());
   EXPECT_TRUE(test_observer_->output_mute_by_system());
 }
 
 }  // namespace chromeos