Exclude non-simple-usage audio nodes from being selected as primary node, and do not persist their …

chromeos/audio/cras_audio_handler.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 <algorithm>
@@ skipping 407 matching lines @@
     const AudioDevice& device = it->second;
     if (device.is_input != active_device.is_input)
       continue;
     SaveDeviceState(device, device.active, activate_by);
   }
 }
 
 void CrasAudioHandler::SaveDeviceState(const AudioDevice& device,
                                        bool active,
                                        DeviceActivateType activate_by) {
+  // Don't save the active state for non-simple usage device, which is invisible
+  // to end users.
+  if (!device.is_for_simple_usage())
+    return;
+
   if (!active) {
     audio_pref_handler_->SetDeviceActive(device, false, false);
   } else {
     switch (activate_by) {
       case ACTIVATE_BY_USER:
         audio_pref_handler_->SetDeviceActive(device, true, true);
         break;
       case ACTIVATE_BY_PRIORITY:
         audio_pref_handler_->SetDeviceActive(device, true, false);
         break;
@@ skipping 479 matching lines @@
     FOR_EACH_OBSERVER(AudioObserver, observers_, OnActiveOutputNodeChanged());
 }
 
 bool CrasAudioHandler::GetActiveDeviceFromUserPref(bool is_input,
                                                    AudioDevice* active_device) {
   bool found_active_device = false;
   bool last_active_device_activate_by_user = false;
   for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
        it != audio_devices_.end(); ++it) {
     AudioDevice device = it->second;
-    if (device.is_input != is_input)
+    if (device.is_input != is_input || !device.is_for_simple_usage())
       continue;
 
     bool active = false;
     bool activate_by_user = false;
     if (!audio_pref_handler_->GetDeviceActive(device, &active,
                                               &activate_by_user) ||
         !active) {
       continue;
     }
 
@@ skipping 48 matching lines @@
     bool has_device_removed,
     bool active_device_removed) {
   bool has_current_active_node =
       is_input ? active_input_node_id_ : active_output_node_id_;
 
   // No device change, extra NodesChanged signal received.
   if (!has_device_change && has_current_active_node)
     return;
 
   if (hotplug_nodes.empty()) {
-    // Unplugged a non-active device.
     if (has_device_removed) {
       if (!active_device_removed && has_current_active_node) {
         // Removed a non-active device, keep the current active device.
         return;
       }
 
       if (active_device_removed) {
         // Unplugged the current active device.
         SwitchToTopPriorityDevice(is_input);
         return;
       }
     }
 
     // Some unexpected error happens on cras side. See crbug.com/586026.
     // Either cras sent stale nodes to chrome again or cras triggered some
     // error. Restore the previously selected active.
-    VLOG(1) << "Odd case from cras, the active node is lost unexpectedly. ";
+    VLOG(1) << "Odd case from cras, the active node is lost unexpectedly.";
     SwitchToPreviousActiveDeviceIfAvailable(is_input);
   } else {
     // Looks like a new chrome session starts.
     SwitchToPreviousActiveDeviceIfAvailable(is_input);
   }
 }
 
 void CrasAudioHandler::HandleHotPlugDevice(
     const AudioDevice& hotplug_device,
     const AudioDevicePriorityQueue& device_priority_queue) {
+  // This most likely may happen during the transition period of cras
+  // initialization phase, in which a non-simple-usage node may appear like
+  // a hotplug node.
+  if (!hotplug_device.is_for_simple_usage())
+    return;
+
   bool last_state_active = false;
   bool last_activate_by_user = false;
   if (!audio_pref_handler_->GetDeviceActive(hotplug_device, &last_state_active,
                                             &last_activate_by_user)) {
     // |hotplug_device| is plugged in for the first time, activate it if it
     // is of the highest priority.
     if (device_priority_queue.top().id == hotplug_device.id) {
       VLOG(1) << "Hotplug a device for the first time: "
               << hotplug_device.ToString();
       SwitchToDevice(hotplug_device, true, ACTIVATE_BY_PRIORITY);
     }
   } else if (last_state_active) {
     VLOG(1) << "Hotplug a device, restore to active: "
             << hotplug_device.ToString();
     SwitchToDevice(hotplug_device, true, ACTIVATE_BY_RESTORE_PREVIOUS_STATE);
   } else {
     // Do not active the device if its previous state is inactive.
     VLOG(1) << "Hotplug device remains inactive as its previous state:"
             << hotplug_device.ToString();
   }
 }
 
 void CrasAudioHandler::SwitchToTopPriorityDevice(bool is_input) {
   AudioDevice top_device =
       is_input ? input_devices_pq_.top() : output_devices_pq_.top();
-  SwitchToDevice(top_device, true, ACTIVATE_BY_PRIORITY);
+  if (top_device.is_for_simple_usage())
+    SwitchToDevice(top_device, true, ACTIVATE_BY_PRIORITY);
 }
 
 void CrasAudioHandler::SwitchToPreviousActiveDeviceIfAvailable(bool is_input) {
   AudioDevice previous_active_device;
   if (GetActiveDeviceFromUserPref(is_input, &previous_active_device)) {
+    DCHECK(previous_active_device.is_for_simple_usage());
     // Switch to previous active device stored in user prefs.
     SwitchToDevice(previous_active_device, true,
                    ACTIVATE_BY_RESTORE_PREVIOUS_STATE);
   } else {
     // No previous active device, switch to the top priority device.
     SwitchToTopPriorityDevice(is_input);
   }
 }
 
 void CrasAudioHandler::UpdateDevicesAndSwitchActive(
@@ skipping 201 matching lines @@
                      hdmi_rediscover_grace_period_duration_in_ms_),
       this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
 }
 
 void CrasAudioHandler::SetHDMIRediscoverGracePeriodForTesting(
     int duration_in_ms) {
   hdmi_rediscover_grace_period_duration_in_ms_ = duration_in_ms;
 }
 
 }  // namespace chromeos