Implement HasInputDevices in CrasAudioManager

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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.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/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using testing::NiceMock;
+using testing::StrictMock;
+
 namespace chromeos {
 
 const uint64 kInternalSpeakerId = 10001;
 const uint64 kHeadphoneId = 10002;
 const uint64 kInternalMicId = 10003;
 const uint64 kUSBMicId = 10004;
 const uint64 kBluetoothHeadsetId = 10005;
-const uint64 kHDMIOutputId = 10006;
-const uint64 kUSBHeadphoneId1 = 10007;
-const uint64 kUSBHeadphoneId2 = 10008;
-const uint64 kMicJackId = 10009;
-const uint64 kKeyboardMicId = 10010;
+const uint64 kBluetoothHeadsetMicId = 10006;
+const uint64 kHDMIOutputId = 10007;
+const uint64 kUSBHeadphoneId1 = 10008;
+const uint64 kUSBHeadphoneId2 = 10009;
+const uint64 kMicJackId = 10010;
+const uint64 kKeyboardMicId = 10011;
+const uint64 kPostMixLoopbackId = 10012;
+const uint64 kPostDSPLoopbackId = 10013;
+const uint64 kAOKRId = 10014;
 const uint64 kOtherTypeOutputId = 90001;
 const uint64 kOtherTypeInputId = 90002;
 const uint64 kUSBJabraSpeakerOutputId1 = 90003;
 const uint64 kUSBJabraSpeakerOutputId2 = 90004;
 const uint64 kUSBJabraSpeakerInputId1 = 90005;
 const uint64 kUSBJabraSpeakerInputId2 = 90006;
 const uint64 kUSBCameraInputId = 90007;
 
 const AudioNode kInternalSpeaker(
     false,
@@ skipping 68 matching lines @@
 const AudioNode kOtherTypeInput(
     true,
     kOtherTypeInputId,
     "Input Device",
     "SOME_OTHER_TYPE",
     "Other Type Input Device",
     false,
     0
 );
 
+const AudioNode kPostMixLoopback(false,
+                                 kPostMixLoopbackId,
+                                 "Fake Post Mix Loopback",
+                                 "POST_MIX_LOOPBACK",
+                                 "Post Mix Loopback",
+                                 false,
+                                 0);
+
+const AudioNode kPostDSPLoopback(false,
+                                 kPostDSPLoopbackId,
+                                 "Fake Post DSP Loopback",
+                                 "POST_DSP_LOOPBACK",
+                                 "Post DSP Loopback",
+                                 false,
+                                 0);
+
+const AudioNode kAOKR(true,
+                      kAOKRId,
+                      "Fake AOKR Mic",
+                      "AOKR",
+                      "AOKR Mic",
+                      false,
+                      0);
+
 const AudioNode kBluetoothHeadset(false,
                                   kBluetoothHeadsetId,
                                   "Bluetooth Headset",
                                   "BLUETOOTH",
                                   "Bluetooth Headset 1",
                                   false,
                                   0);
 
+const AudioNode kBluetoothHeadsetMic(true,
+                                     kBluetoothHeadsetMicId,
+                                     "Bluetooth Headset",
+                                     "BLUETOOTH",
+                                     "Bluetooth Headset 1",
+                                     false,
+                                     0);
+
 const AudioNode kHDMIOutput(false,
                             kHDMIOutputId,
                             "HDMI output",
                             "HDMI",
                             "HDMI output",
                             false,
                             0);
 
 const AudioNode kUSBHeadphone1(false,
                                kUSBHeadphoneId1,
@@ skipping 134 matching lines @@
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
+// AudioManagerWrapper is mocked in unittest because unittest is run in an
+// environment without AudioManagerCras.
+class MockAudioManagerWrapper : public CrasAudioHandler::AudioManagerWrapper {
+ public:
+  MockAudioManagerWrapper() {}
+  ~MockAudioManagerWrapper() override {}
+  MOCK_METHOD1(SetHasInputDevices, void(bool has_input_devices));
+};
+
 class CrasAudioHandlerTest : public testing::Test {
  public:
-  CrasAudioHandlerTest() : cras_audio_handler_(NULL),
-                           fake_cras_audio_client_(NULL) {
-  }
+  CrasAudioHandlerTest()
+      : cras_audio_handler_(NULL),
+        fake_cras_audio_client_(NULL),
+        use_nice_mock_audio_manager_(true) {}
   ~CrasAudioHandlerTest() override {}
 
   void SetUp() override {}
 
   void TearDown() override {
     cras_audio_handler_->RemoveAudioObserver(test_observer_.get());
     test_observer_.reset();
     CrasAudioHandler::Shutdown();
     audio_pref_handler_ = NULL;
     DBusThreadManager::Shutdown();
   }
 
+  // This is for the cases where the test does not care
+  // audio manager behavior.
+  void SetUpDefaultNiceMockAudioManagerIfNeeded() {
+    if (use_nice_mock_audio_manager_)
+      SetUpNiceMockAudioManager();
+  }
+
+  void SetUpNiceMockAudioManager() {
+    nice_mock_audio_manager_ = new NiceMock<MockAudioManagerWrapper>();
+    CrasAudioHandler::SetUpAudioManagerWrapperForTesting(
+        nice_mock_audio_manager_);
+  }
+
+  // Set the expected method and arguments on strict_mock_audio_manager_ to
+  // check that SetHasInputDevices is called with correct argument when a
+  // list of audio nodes present in CrasAudioHandler.
+  void CheckSetHasInputDevices(AudioNodeList audio_nodes,
+                               bool has_input_devices) {
+    use_nice_mock_audio_manager_ = false;
+    SetUpStrictMockAudioManager();
+    EXPECT_CALL(*strict_mock_audio_manager_,
+                SetHasInputDevices(has_input_devices));
+    SetUpCrasAudioHandler(audio_nodes);
+  }
+
+  void SetUpStrictMockAudioManager() {
+    strict_mock_audio_manager_ = new StrictMock<MockAudioManagerWrapper>();
+    CrasAudioHandler::SetUpAudioManagerWrapperForTesting(
+        strict_mock_audio_manager_);
+  }
+
   void SetUpCrasAudioHandler(const AudioNodeList& audio_nodes) {
     DBusThreadManager::Initialize();
     fake_cras_audio_client_ = static_cast<FakeCrasAudioClient*>(
         DBusThreadManager::Get()->GetCrasAudioClient());
     fake_cras_audio_client_->SetAudioNodesForTesting(audio_nodes);
     audio_pref_handler_ = new AudioDevicesPrefHandlerStub();
+    SetUpDefaultNiceMockAudioManagerIfNeeded();
     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();
+    SetUpDefaultNiceMockAudioManagerIfNeeded();
     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 ChangeAudioNodes(const AudioNodeList& audio_nodes) {
     fake_cras_audio_client_->SetAudioNodesAndNotifyObserversForTesting(
         audio_nodes);
@@ skipping 14 matching lines @@
     }
     return num_active_nodes;
   }
 
  protected:
   base::MessageLoopForUI message_loop_;
   CrasAudioHandler* cras_audio_handler_;  // Not owned.
   FakeCrasAudioClient* fake_cras_audio_client_;  // Not owned.
   scoped_ptr<TestObserver> test_observer_;
   scoped_refptr<AudioDevicesPrefHandlerStub> audio_pref_handler_;
+  NiceMock<MockAudioManagerWrapper>* nice_mock_audio_manager_;
+  StrictMock<MockAudioManagerWrapper>* strict_mock_audio_manager_;
+  bool use_nice_mock_audio_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CrasAudioHandlerTest);
 };
 
 TEST_F(CrasAudioHandlerTest, InitializeWithOnlyDefaultAudioDevices) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalSpeaker);
   audio_nodes.push_back(kInternalMic);
   SetUpCrasAudioHandler(audio_nodes);
@@ skipping 2124 matching lines @@
   audio_nodes.push_back(kHDMIOutput);
   ChangeAudioNodes(audio_nodes);
 
   // Verify the headphone is set to active again.
   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetPrimaryActiveOutputNode());
   const AudioDevice* headphone_resumed = GetDeviceFromId(kHeadphone.id);
   EXPECT_EQ(kHeadphone.id, headphone_resumed->id);
   EXPECT_TRUE(headphone_resumed->active);
 }
 
+// Test the case where there is no input device in the beginning.
+// SetHasInputDevices on AudioManagerWrapper is called with argument false.
+// After a mic jack is plugged, CrasAudioHandler calls SetHasInputDevices on
+// AudioManagerWrapper with argument true.
+TEST_F(CrasAudioHandlerTest, PlugMicJackAndUpdateAudioManager) {
+  // Set up audio handler with output nodes and input nodes for loopback.
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  audio_nodes.push_back(kPostMixLoopback);
+  audio_nodes.push_back(kPostDSPLoopback);
+
+  // SetHasInputAudioDevices should be called with argument false.
+  use_nice_mock_audio_manager_ = false;
+  SetUpStrictMockAudioManager();
+  EXPECT_CALL(*strict_mock_audio_manager_, SetHasInputDevices(false));
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Plug the Mic Jack. SetHasInputAudioDevices should get called with argument
+  // true.
+  audio_nodes.push_back(kMicJack);
+  EXPECT_CALL(*strict_mock_audio_manager_, SetHasInputDevices(true));
+  ChangeAudioNodes(audio_nodes);
+}
+
+// Test the case where there is no input device for simple usage.
+// SetHasInputDevices on AudioManagerWrapper is called with argument false.
+TEST_F(CrasAudioHandlerTest, SetHasInputDeviceToFalse) {
+  AudioNodeList audio_nodes = {kHeadphone,

[Daniel Erat, 2015/06/23 14:15:49]

i don't think that this initialization style is allowed in chromium: see
"(Uniform) Initialization Syntax" at http://chromium-cpp.appspot.com/

[cychiang, 2015/06/24 08:11:29]

Done.

+                               kUSBHeadphone1,
+                               kBluetoothHeadset,
+                               kHDMIOutput,
+                               kInternalSpeaker,
+                               kKeyboardMic,
+                               kAOKR,
+                               kPostMixLoopback,
+                               kPostDSPLoopback,
+                               kOtherTypeOutput,
+                               kOtherTypeInput};
+  CheckSetHasInputDevices(audio_nodes, false);
+}
+
+// Test the case where there is an internal mic.
+// SetHasInputDevices on AudioManagerWrapper is called with argument true.
+TEST_F(CrasAudioHandlerTest, SetHasInputDeviceToTrueForInternalMic) {
+  AudioNodeList audio_nodes = {kInternalMic};
+  CheckSetHasInputDevices(audio_nodes, true);
+}
+
+// Test the case where there is an external mic.
+// SetHasInputDevices on AudioManagerWrapper is called with argument true.
+TEST_F(CrasAudioHandlerTest, SetHasInputDeviceToTrueForMicJack) {
+  AudioNodeList audio_nodes = {kMicJack};
+  CheckSetHasInputDevices(audio_nodes, true);
+}
+
+// Test the case where there is a USB mic.
+// SetHasInputDevices on AudioManagerWrapper is called with argument true.
+TEST_F(CrasAudioHandlerTest, SetHasInputDeviceToTrueForUSBMic) {
+  AudioNodeList audio_nodes = {kUSBMic};
+  CheckSetHasInputDevices(audio_nodes, true);
+}
+
+// Test the case where there is a bluetooth mic.
+// SetHasInputDevices on AudioManagerWrapper is called with argument true.
+TEST_F(CrasAudioHandlerTest, SetHasInputDeviceToTrueForBluetoothMic) {
+  AudioNodeList audio_nodes = {kBluetoothHeadsetMic};
+  CheckSetHasInputDevices(audio_nodes, true);
+}
+
 }  // namespace chromeos