cras_audio_handler add SetOutputMono method

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"
@@ skipping 188 matching lines @@
 class TestObserver : public chromeos::CrasAudioHandler::AudioObserver {
  public:
   TestObserver()
       : active_output_node_changed_count_(0),
         active_input_node_changed_count_(0),
         audio_nodes_changed_count_(0),
         output_mute_changed_count_(0),
         input_mute_changed_count_(0),
         output_volume_changed_count_(0),
         input_gain_changed_count_(0),
-        output_mute_by_system_(false) {}
+        output_mute_by_system_(false),
+        output_channel_remixing_changed_count_(0) {}
 
   int active_output_node_changed_count() const {
     return active_output_node_changed_count_;
   }
 
   void reset_active_output_node_changed_count() {
     active_output_node_changed_count_ = 0;
   }
 
   int active_input_node_changed_count() const {
@@ skipping 21 matching lines @@
   int output_volume_changed_count() const {
     return output_volume_changed_count_;
   }
 
   int input_gain_changed_count() const {
     return input_gain_changed_count_;
   }
 
   bool output_mute_by_system() const { return output_mute_by_system_; }
 
+  int output_channel_remixing_changed_count() const {
+    return output_channel_remixing_changed_count_;
+  }
+
   ~TestObserver() override {}
 
  protected:
   // chromeos::CrasAudioHandler::AudioObserver overrides.
   void OnActiveOutputNodeChanged() override {
     ++active_output_node_changed_count_;
   }
 
   void OnActiveInputNodeChanged() override {
     ++active_input_node_changed_count_;
@@ skipping 12 matching lines @@
 
   void OnOutputNodeVolumeChanged(uint64_t /* node_id */,
                                  int /* volume */) override {
     ++output_volume_changed_count_;
   }
 
   void OnInputNodeGainChanged(uint64_t /* node_id */, int /* gain */) override {
     ++input_gain_changed_count_;
   }
 
+  void OnOuputChannelRemixingChanged(bool /* mono_on */) override {
+    ++output_channel_remixing_changed_count_;
+  }
+
  private:
   int active_output_node_changed_count_;
   int active_input_node_changed_count_;
   int audio_nodes_changed_count_;
   int output_mute_changed_count_;
   int input_mute_changed_count_;
   int output_volume_changed_count_;
   int input_gain_changed_count_;
   bool output_mute_by_system_;  // output mute state adjusted by system.
+  int output_channel_remixing_changed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 }  // namespace
 
 class CrasAudioHandlerTest : public testing::Test {
  public:
   CrasAudioHandlerTest() : cras_audio_handler_(NULL),
                            fake_cras_audio_client_(NULL) {
@@ skipping 1577 matching lines @@
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(internal_speaker.id, active_output.id);
   EXPECT_TRUE(active_output.active);
 
   // Verify the active input device id is set to internal mic.
   EXPECT_EQ(internal_mic.id, cras_audio_handler_->GetPrimaryActiveInputNode());
   const AudioDevice* changed_active_input = GetDeviceFromId(internal_mic.id);
   EXPECT_TRUE(changed_active_input->active);
 }
 
+TEST_F(CrasAudioHandlerTest, SetOutputMono) {
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kHeadphone);
+  SetUpCrasAudioHandler(audio_nodes);
+  EXPECT_EQ(0, test_observer_->output_channel_remixing_changed_count());
+
+  // Set output mono
+  cras_audio_handler_->SetOutputMono(true);
+
+  // Verify the output is in mono mode, OnOuputChannelRemixingChanged event
+  // is fired.
+  EXPECT_TRUE(cras_audio_handler_->IsOutputMonoEnabled());
+  EXPECT_EQ(1, test_observer_->output_channel_remixing_changed_count());
+
+  // Set output stereo
+  cras_audio_handler_->SetOutputMono(false);
+  EXPECT_FALSE(cras_audio_handler_->IsOutputMonoEnabled());
+  EXPECT_EQ(2, test_observer_->output_channel_remixing_changed_count());
+}
+
 TEST_F(CrasAudioHandlerTest, SetOutputMute) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalSpeaker);
   SetUpCrasAudioHandler(audio_nodes);
   EXPECT_EQ(0, test_observer_->output_mute_changed_count());
 
   // Mute the device.
   cras_audio_handler_->SetOutputMute(true);
 
   // Verify the output is muted, OnOutputMuteChanged event is fired,
@@ skipping 1167 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