Simplify logic behind chrome.audio.setActiveDevices

chromeos/audio/cras_audio_handler.h

 // 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.
 
 #ifndef CHROMEOS_AUDIO_CRAS_AUDIO_HANDLER_H_
 #define CHROMEOS_AUDIO_CRAS_AUDIO_HANDLER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <queue>
@@ skipping 86 matching lines @@
   // Destroys the global instance.
   static void Shutdown();
 
   // Returns true if the global instance is initialized.
   static bool IsInitialized();
 
   // Gets the global instance. Initialize must be called first.
   static CrasAudioHandler* Get();
 
   // Adds an audio observer.
-  virtual void AddAudioObserver(AudioObserver* observer);
+  void AddAudioObserver(AudioObserver* observer);
 
   // Removes an audio observer.
-  virtual void RemoveAudioObserver(AudioObserver* observer);
+  void RemoveAudioObserver(AudioObserver* observer);
 
   // Returns true if keyboard mic exists.
-  virtual bool HasKeyboardMic();
+  bool HasKeyboardMic();
 
   // Returns true if audio output is muted for the system.
-  virtual bool IsOutputMuted();
+  bool IsOutputMuted();
 
   // Returns true if audio output is muted for a device.
-  virtual bool IsOutputMutedForDevice(uint64_t device_id);
+  bool IsOutputMutedForDevice(uint64_t device_id);
 
   // Returns true if audio input is muted.
-  virtual bool IsInputMuted();
+  bool IsInputMuted();
 
   // Returns true if audio input is muted for a device.
-  virtual bool IsInputMutedForDevice(uint64_t device_id);
+  bool IsInputMutedForDevice(uint64_t device_id);
 
   // Returns true if the output volume is below the default mute volume level.
-  virtual bool IsOutputVolumeBelowDefaultMuteLevel();
+  bool IsOutputVolumeBelowDefaultMuteLevel();
 
   // Returns volume level in 0-100% range at which the volume should be muted.
-  virtual int GetOutputDefaultVolumeMuteThreshold();
+  int GetOutputDefaultVolumeMuteThreshold();
 
   // Gets volume level in 0-100% range (0 being pure silence) for the current
   // active node.
-  virtual int GetOutputVolumePercent();
+  int GetOutputVolumePercent();
 
   // Gets volume level in 0-100% range (0 being pure silence) for a device.
-  virtual int GetOutputVolumePercentForDevice(uint64_t device_id);
+  int GetOutputVolumePercentForDevice(uint64_t device_id);
 
   // Gets gain level in 0-100% range (0 being pure silence) for the current
   // active node.
-  virtual int GetInputGainPercent();
+  int GetInputGainPercent();
 
   // Gets volume level in 0-100% range (0 being pure silence) for a device.
-  virtual int GetInputGainPercentForDevice(uint64_t device_id);
+  int GetInputGainPercentForDevice(uint64_t device_id);
 
   // Returns node_id of the primary active output node.
-  virtual uint64_t GetPrimaryActiveOutputNode() const;
+  uint64_t GetPrimaryActiveOutputNode() const;
 
   // Returns the node_id of the primary active input node.
-  virtual uint64_t GetPrimaryActiveInputNode() const;
+  uint64_t GetPrimaryActiveInputNode() const;
 
   // Gets the audio devices back in |device_list|.
   // This call can be invoked from I/O thread or UI thread because
   // it does not need to access CrasAudioClient on DBus.
-  virtual void GetAudioDevices(AudioDeviceList* device_list) const;
+  void GetAudioDevices(AudioDeviceList* device_list) const;
 
-  virtual bool GetPrimaryActiveOutputDevice(AudioDevice* device) const;
+  bool GetPrimaryActiveOutputDevice(AudioDevice* device) const;
 
   // Whether there is alternative input/output audio device.
-  virtual bool has_alternative_input() const;
-  virtual bool has_alternative_output() const;
+  bool has_alternative_input() const;
+  bool has_alternative_output() const;
 
   // Sets all active output devices' volume levels to |volume_percent|, whose
   // range is from 0-100%.
-  virtual void SetOutputVolumePercent(int volume_percent);
+  void SetOutputVolumePercent(int volume_percent);
 
   // Sets all active output devices' volume levels to |volume_percent|, whose
   // range is from 0-100%, without notifying observers.
-  virtual void SetOutputVolumePercentWithoutNotifyingObservers(
+  void SetOutputVolumePercentWithoutNotifyingObservers(
       int volume_percent,
       AutomatedVolumeChangeReason reason);
 
   // Sets all active input devices' gain level to |gain_percent|, whose range is
   // from 0-100%.
-  virtual void SetInputGainPercent(int gain_percent);
+  void SetInputGainPercent(int gain_percent);
 
   // Adjusts all active output devices' volume up (positive percentage) or down
   // (negative percentage).
-  virtual void AdjustOutputVolumeByPercent(int adjust_by_percent);
+  void AdjustOutputVolumeByPercent(int adjust_by_percent);
 
   // Adjusts all active output devices' volume to a minimum audible level if it
   // is too low.
-  virtual void AdjustOutputVolumeToAudibleLevel();
+  void AdjustOutputVolumeToAudibleLevel();
 
   // Mutes or unmutes audio output device.
-  virtual void SetOutputMute(bool mute_on);
+  void SetOutputMute(bool mute_on);
 
   // Mutes or unmutes audio input device.
-  virtual void SetInputMute(bool mute_on);
+  void SetInputMute(bool mute_on);
 
   // Switches active audio device to |device|. |activate_by| indicates why
   // the device is switched to active: by user's manual choice, by priority,
   // or by restoring to its previous active state.
-  virtual void SwitchToDevice(const AudioDevice& device,
-                              bool notify,
-                              DeviceActivateType activate_by);
+  void SwitchToDevice(const AudioDevice& device,
+                      bool notify,
+                      DeviceActivateType activate_by);
 
   // Sets volume/gain level for a device.
-  virtual void SetVolumeGainPercentForDevice(uint64_t device_id, int value);
+  void SetVolumeGainPercentForDevice(uint64_t device_id, int value);
 
   // Sets the mute for device.
-  virtual void SetMuteForDevice(uint64_t device_id, bool mute_on);
+  void SetMuteForDevice(uint64_t device_id, bool mute_on);
 
   // Activates or deactivates keyboard mic if there's one.
-  virtual void SetKeyboardMicActive(bool active);
+  void SetKeyboardMicActive(bool active);
 
   // Changes the active nodes to the nodes specified by |new_active_ids|.
   // The caller can pass in the "complete" active node list of either input
   // nodes, or output nodes, or both. If only input nodes are passed in,
   // it will only change the input nodes' active status, output nodes will NOT
   // be changed; similarly for the case if only output nodes are passed.
   // If the nodes specified in |new_active_ids| are already active, they will
   // remain active. Otherwise, the old active nodes will be de-activated before
   // we activate the new nodes with the same type(input/output).
-  virtual void ChangeActiveNodes(const NodeIdList& new_active_ids);
+  // DEPRECATED in favour of |SetActiveInputNodes| and |SetActiveOutputNodes|.

[jennyz, 2017/01/07 00:33:00]

nit: favour -> favor

[tbarzic, 2017/01/07 05:16:31]

Done.

+  void ChangeActiveNodes(const NodeIdList& new_active_ids);
+
+  // Sets the set of active input nodes. Empty |node_ids| will deactivate all
+  // input devices.
+  // |node_ids| is expected to contain only existing input node IDs - the
+  // method will fail if this is not the case.
+  // Returns whether the acive nodes were successfully set.
+  bool SetActiveInputNodes(const NodeIdList& node_ids);
+
+  // Sets the set of active output nodes. Empty |node_ids| will deactivate all
+  // output devices.
+  // |node_ids| is expected to contain only existing output node IDs - the
+  // method will fail if this is not the case.
+  // Returns whether the acive nodes were successfully set.
+  bool SetActiveOutputNodes(const NodeIdList& node_ids);
 
   // Swaps the left and right channel of the internal speaker.
   // Swap the left and right channel if |swap| is true; otherwise, swap the left
   // and right channel back to the normal mode.
   // If the feature is not supported on the device, nothing happens.
-  virtual void SwapInternalSpeakerLeftRightChannel(bool swap);
+  void SwapInternalSpeakerLeftRightChannel(bool swap);
 
   // Accessibility audio setting: sets the output mono or not.
-  virtual void SetOutputMono(bool mono_on);
+  void SetOutputMono(bool mono_on);
 
   // Returns true if output mono is enabled.
-  virtual bool IsOutputMonoEnabled() const;
+  bool IsOutputMonoEnabled() const;
 
   // Enables error logging.
-  virtual void LogErrors();
+  void LogErrors();
 
   // If necessary, sets the starting point for re-discovering the active HDMI
   // output device caused by device entering/exiting docking mode, HDMI display
   // changing resolution, or chromeos device suspend/resume. If
   // |force_rediscovering| is true, it will force to set the starting point for
   // re-discovering the active HDMI output device again if it has been in the
   // middle of rediscovering the HDMI active output device.
-  virtual void SetActiveHDMIOutoutRediscoveringIfNecessary(
-      bool force_rediscovering);
+  void SetActiveHDMIOutoutRediscoveringIfNecessary(bool force_rediscovering);
 
-  virtual const AudioDevice* GetDeviceFromId(uint64_t device_id) const;
+  const AudioDevice* GetDeviceFromId(uint64_t device_id) const;
 
  protected:
   explicit CrasAudioHandler(
       scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler);
   ~CrasAudioHandler() override;
 
  private:
   friend class CrasAudioHandlerTest;
 
   // CrasAudioClient::Observer overrides.
@@ skipping 10 matching lines @@
   void EmitLoginPromptVisibleCalled() override;
 
   // Sets the |active_device| to be active.
   // If |notify|, notifies Active*NodeChange.
   // Saves device active states in prefs. |activate_by| indicates how
   // the device was activated.
   void SetActiveDevice(const AudioDevice& active_device,
                        bool notify,
                        DeviceActivateType activate_by);
 
+  // Shared implementation for |SetActiveInputNodes| and |SetActiveOutputNodes|.
+  bool SetActiveNodes(const NodeIdList& node_ids, bool is_input);
+
   // Sets list of active input or output nodes to |devices|.
   // If |is_input| is set, active input nodes will be set, otherwise active
   // output nodes will be set.
   // For each device in |devices| it is expected device.is_input == is_input.
-  void SetActiveNodes(const AudioDeviceList& devices, bool is_input);
+  void SetActiveDevices(const AudioDeviceList& devices, bool is_input);
 
   // Saves |device|'s state in pref. If |active| is true, |activate_by|
   // indicates how |device| is activated.
   void SaveDeviceState(const AudioDevice& device,
                        bool active,
                        DeviceActivateType activate_by);
 
   // Sets up the audio device state based on audio policy and audio settings
   // saved in prefs.
   void SetupAudioInputState();
@@ skipping 173 matching lines @@
   uint64_t init_node_id_;
 
   base::WeakPtrFactory<CrasAudioHandler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CrasAudioHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_AUDIO_CRAS_AUDIO_HANDLER_H_