extensions/shell/browser/shell_audio_controller_chromeos_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/shell/browser/shell_audio_controller_chromeos.h"
   6
   7 #include "base/macros.h"
   8 #include "chromeos/audio/audio_device.h"
   9 #include "chromeos/audio/cras_audio_handler.h"
  10 #include "chromeos/dbus/audio_node.h"
  11 #include "chromeos/dbus/cras_audio_client_stub_impl.h"
  12 #include "chromeos/dbus/dbus_thread_manager.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using chromeos::AudioDevice;
  16 using chromeos::AudioNode;
  17 using chromeos::AudioNodeList;
  18
  19 namespace extensions {
  20
  21 class ShellAudioControllerTest : public testing::Test {
  22  public:
  23   ShellAudioControllerTest() : next_node_id_(1) {
  24     // This also initializes DBusThreadManager.
  25     scoped_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
  26         chromeos::DBusThreadManager::GetSetterForTesting();
  27
  28     audio_client_ = new chromeos::CrasAudioClientStubImpl();
  29     audio_client_->SetAudioNodesForTesting(AudioNodeList());
  30     dbus_setter->SetCrasAudioClient(
  31         make_scoped_ptr(audio_client_).PassAs<chromeos::CrasAudioClient>());
  32
  33     chromeos::CrasAudioHandler::Initialize(
  34         new ShellAudioController::PrefHandler());
  35     audio_handler_ = chromeos::CrasAudioHandler::Get();
  36
  37     controller_.reset(new ShellAudioController());
  38   }
  39
  40   virtual ~ShellAudioControllerTest() {
  41     controller_.reset();
  42     chromeos::CrasAudioHandler::Shutdown();
  43     chromeos::DBusThreadManager::Shutdown();
  44   }
  45
  46  protected:
  47   // Fills a AudioNode for use by tests.
  48   AudioNode CreateNode(chromeos::AudioDeviceType type) {
  49     AudioNode node;
  50     node.is_input =
  51         type == chromeos::AUDIO_TYPE_MIC ||
  52         type == chromeos::AUDIO_TYPE_INTERNAL_MIC ||
  53         type == chromeos::AUDIO_TYPE_KEYBOARD_MIC;
  54     node.id = next_node_id_++;
  55     node.type = AudioDevice::GetTypeString(type);
  56     return node;
  57   }
  58
  59   // Changes the active state of the node with |id| in |nodes|.
  60   void SetNodeActive(AudioNodeList* nodes, uint64 id, bool active) {
  61     for (AudioNodeList::iterator it = nodes->begin();
  62          it != nodes->end(); ++it) {
  63       if (it->id == id) {
  64         it->active = active;
  65         return;
  66       }
  67     }
  68     ASSERT_TRUE(false) << "Didn't find ID " << id;
  69   }
  70
  71   chromeos::CrasAudioClientStubImpl* audio_client_;  // Not owned.
  72   chromeos::CrasAudioHandler* audio_handler_;  // Not owned.
  73   scoped_ptr<ShellAudioController> controller_;
  74
  75   // Next audio node ID to be returned by CreateNode().
  76   uint64 next_node_id_;
  77
  78  private:
  79   DISALLOW_COPY_AND_ASSIGN(ShellAudioControllerTest);
  80 };
  81
  82 // Tests that higher-priority devices are activated as soon as they're
  83 // connected.
  84 TEST_F(ShellAudioControllerTest, SelectBestDevices) {
  85   AudioNode internal_speaker =
  86       CreateNode(chromeos::AUDIO_TYPE_INTERNAL_SPEAKER);
  87   AudioNode internal_mic = CreateNode(chromeos::AUDIO_TYPE_INTERNAL_MIC);
  88   AudioNode headphone = CreateNode(chromeos::AUDIO_TYPE_HEADPHONE);
  89   AudioNode external_mic = CreateNode(chromeos::AUDIO_TYPE_MIC);
  90
  91   // AudioDevice gives the headphone jack a higher priority than the internal
  92   // speaker and an external mic a higher priority than the internal mic, so we
  93   // should start out favoring headphones and the external mic.
  94   AudioNodeList all_nodes;
  95   all_nodes.push_back(internal_speaker);
  96   all_nodes.push_back(internal_mic);
  97   all_nodes.push_back(headphone);
  98   all_nodes.push_back(external_mic);
  99   audio_client_->SetAudioNodesAndNotifyObserversForTesting(all_nodes);
 100   EXPECT_EQ(headphone.id, audio_handler_->GetPrimaryActiveOutputNode());
 101   EXPECT_EQ(external_mic.id, audio_handler_->GetPrimaryActiveInputNode());
 102
 103   // Unplug the headphones and mic and check that we switch to the internal
 104   // devices.
 105   AudioNodeList internal_nodes;
 106   internal_nodes.push_back(internal_speaker);
 107   internal_nodes.push_back(internal_mic);
 108   audio_client_->SetAudioNodesAndNotifyObserversForTesting(internal_nodes);
 109   EXPECT_EQ(internal_speaker.id, audio_handler_->GetPrimaryActiveOutputNode());
 110   EXPECT_EQ(internal_mic.id, audio_handler_->GetPrimaryActiveInputNode());
 111
 112   // Switch back to the external devices. Mark the previously-activated internal
 113   // devices as being active so CrasAudioHandler doesn't complain.
 114   SetNodeActive(&all_nodes, internal_speaker.id, true);
 115   SetNodeActive(&all_nodes, internal_mic.id, true);
 116   audio_client_->SetAudioNodesAndNotifyObserversForTesting(all_nodes);
 117   EXPECT_EQ(headphone.id, audio_handler_->GetPrimaryActiveOutputNode());
 118   EXPECT_EQ(external_mic.id, audio_handler_->GetPrimaryActiveInputNode());
 119 }
 120
 121 // Tests that active audio devices are unmuted and set to 100% volume.
 122 TEST_F(ShellAudioControllerTest, MaxVolume) {
 123   AudioNodeList nodes;
 124   nodes.push_back(CreateNode(chromeos::AUDIO_TYPE_INTERNAL_SPEAKER));
 125   nodes.push_back(CreateNode(chromeos::AUDIO_TYPE_INTERNAL_MIC));
 126   audio_client_->SetAudioNodesAndNotifyObserversForTesting(nodes);
 127
 128   EXPECT_FALSE(audio_handler_->IsOutputMuted());
 129   EXPECT_FALSE(audio_handler_->IsInputMuted());
 130   EXPECT_EQ(100, audio_handler_->GetOutputVolumePercent());
 131   EXPECT_EQ(100, audio_handler_->GetInputGainPercent());
 132 }
 133
 134 }  // namespace extensions