chrome/browser/ui/ash/volume_controller_browsertest_chromeos.cc

   1 // Copyright (c) 2012 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 <vector>
   6
   7 #include "ash/ash_switches.h"
   8 #include "base/command_line.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/ui/ash/volume_controller_chromeos.h"
  12 #include "chrome/test/base/in_process_browser_test.h"
  13 #include "chromeos/audio/chromeos_sounds.h"
  14 #include "chromeos/audio/cras_audio_handler.h"
  15 #include "chromeos/chromeos_switches.h"
  16 #include "media/audio/sounds/sounds_manager.h"
  17 #include "ui/base/accelerators/accelerator.h"
  18
  19 namespace {
  20
  21 class SoundsManagerTestImpl : public media::SoundsManager {
  22  public:
  23   SoundsManagerTestImpl()
  24     : is_sound_initialized_(chromeos::SOUND_COUNT),
  25       num_play_requests_(chromeos::SOUND_COUNT) {
  26   }
  27
  28   virtual ~SoundsManagerTestImpl() {}
  29
  30   virtual bool Initialize(SoundKey key,
  31                           const base::StringPiece& /* data */) OVERRIDE {
  32     is_sound_initialized_[key] = true;
  33     return true;
  34   }
  35
  36   virtual bool Play(SoundKey key) OVERRIDE {
  37     ++num_play_requests_[key];
  38     return true;
  39   }
  40
  41   virtual base::TimeDelta GetDuration(SoundKey /* key */) OVERRIDE {
  42     return base::TimeDelta();
  43   }
  44
  45   bool is_sound_initialized(SoundKey key) const {
  46     return is_sound_initialized_[key];
  47   }
  48
  49   int num_play_requests(SoundKey key) const {
  50     return num_play_requests_[key];
  51   }
  52
  53  private:
  54   std::vector<bool> is_sound_initialized_;
  55   std::vector<int> num_play_requests_;
  56
  57   DISALLOW_COPY_AND_ASSIGN(SoundsManagerTestImpl);
  58 };
  59
  60 class VolumeControllerTest : public InProcessBrowserTest {
  61  public:
  62   VolumeControllerTest() {}
  63   virtual ~VolumeControllerTest() {}
  64
  65   virtual void SetUpOnMainThread() OVERRIDE {
  66     volume_controller_.reset(new VolumeController());
  67     audio_handler_ = chromeos::CrasAudioHandler::Get();
  68   }
  69
  70  protected:
  71   void VolumeMute() {
  72     volume_controller_->HandleVolumeMute(ui::Accelerator());
  73   }
  74
  75   void VolumeUp() {
  76     volume_controller_->HandleVolumeUp(ui::Accelerator());
  77   }
  78
  79   void VolumeDown() {
  80     volume_controller_->HandleVolumeDown(ui::Accelerator());
  81   }
  82
  83   chromeos::CrasAudioHandler* audio_handler_;  // Not owned.
  84
  85  private:
  86   scoped_ptr<VolumeController> volume_controller_;
  87
  88   DISALLOW_COPY_AND_ASSIGN(VolumeControllerTest);
  89 };
  90
  91 IN_PROC_BROWSER_TEST_F(VolumeControllerTest, VolumeUpAndDown) {
  92   // Set initial value as 50%
  93   const int kInitVolume = 50;
  94   audio_handler_->SetOutputVolumePercent(kInitVolume);
  95
  96   EXPECT_EQ(audio_handler_->GetOutputVolumePercent(), kInitVolume);
  97
  98   VolumeUp();
  99   EXPECT_LT(kInitVolume, audio_handler_->GetOutputVolumePercent());
 100   VolumeDown();
 101   EXPECT_EQ(kInitVolume, audio_handler_->GetOutputVolumePercent());
 102   VolumeDown();
 103   EXPECT_GT(kInitVolume, audio_handler_->GetOutputVolumePercent());
 104 }
 105
 106 IN_PROC_BROWSER_TEST_F(VolumeControllerTest, VolumeDownToZero) {
 107   // Setting to very small volume.
 108   audio_handler_->SetOutputVolumePercent(1);
 109
 110   VolumeDown();
 111   EXPECT_EQ(0, audio_handler_->GetOutputVolumePercent());
 112   VolumeDown();
 113   EXPECT_EQ(0, audio_handler_->GetOutputVolumePercent());
 114   VolumeUp();
 115   EXPECT_LT(0, audio_handler_->GetOutputVolumePercent());
 116 }
 117
 118 IN_PROC_BROWSER_TEST_F(VolumeControllerTest, VolumeUpTo100) {
 119   // Setting to almost max
 120   audio_handler_->SetOutputVolumePercent(99);
 121
 122   VolumeUp();
 123   EXPECT_EQ(100, audio_handler_->GetOutputVolumePercent());
 124   VolumeUp();
 125   EXPECT_EQ(100, audio_handler_->GetOutputVolumePercent());
 126   VolumeDown();
 127   EXPECT_GT(100, audio_handler_->GetOutputVolumePercent());
 128 }
 129
 130 IN_PROC_BROWSER_TEST_F(VolumeControllerTest, Mutes) {
 131   ASSERT_FALSE(audio_handler_->IsOutputMuted());
 132   const int initial_volume = audio_handler_->GetOutputVolumePercent();
 133
 134   VolumeMute();
 135   EXPECT_TRUE(audio_handler_->IsOutputMuted());
 136
 137   // Further mute buttons doesn't have effects.
 138   VolumeMute();
 139   EXPECT_TRUE(audio_handler_->IsOutputMuted());
 140
 141   // Right after the volume up after set_mute recovers to original volume.
 142   VolumeUp();
 143   EXPECT_FALSE(audio_handler_->IsOutputMuted());
 144   EXPECT_EQ(initial_volume, audio_handler_->GetOutputVolumePercent());
 145
 146   VolumeMute();
 147   // After the volume down, the volume goes down to zero explicitly.
 148   VolumeDown();
 149   EXPECT_TRUE(audio_handler_->IsOutputMuted());
 150   EXPECT_EQ(0, audio_handler_->GetOutputVolumePercent());
 151
 152   // Thus, further VolumeUp doesn't recover the volume, it's just slightly
 153   // bigger than 0.
 154   VolumeUp();
 155   EXPECT_LT(0, audio_handler_->GetOutputVolumePercent());
 156   EXPECT_GT(initial_volume, audio_handler_->GetOutputVolumePercent());
 157 }
 158
 159 class VolumeControllerSoundsTest : public VolumeControllerTest {
 160  public:
 161   VolumeControllerSoundsTest() : sounds_manager_(NULL) {}
 162   virtual ~VolumeControllerSoundsTest() {}
 163
 164   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 165     sounds_manager_ = new SoundsManagerTestImpl();
 166     media::SoundsManager::InitializeForTesting(sounds_manager_);
 167   }
 168
 169   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 170     VolumeControllerTest::SetUpCommandLine(command_line);
 171     command_line->AppendSwitch(ash::switches::kAshEnableSystemSounds);
 172   }
 173
 174   bool is_sound_initialized() const {
 175     return sounds_manager_->is_sound_initialized(
 176         chromeos::SOUND_VOLUME_ADJUST);
 177   }
 178
 179   int num_play_requests() const {
 180     return sounds_manager_->num_play_requests(chromeos::SOUND_VOLUME_ADJUST);
 181   }
 182
 183  private:
 184   SoundsManagerTestImpl* sounds_manager_;
 185
 186   DISALLOW_COPY_AND_ASSIGN(VolumeControllerSoundsTest);
 187 };
 188
 189 IN_PROC_BROWSER_TEST_F(VolumeControllerSoundsTest, VolumeAdjustSounds) {
 190   EXPECT_TRUE(is_sound_initialized());
 191
 192   // Check that sound is played on volume up and volume down.
 193   audio_handler_->SetOutputVolumePercent(50);
 194   VolumeUp();
 195   EXPECT_EQ(1, num_play_requests());
 196   VolumeDown();
 197   EXPECT_EQ(2, num_play_requests());
 198
 199   audio_handler_->SetOutputVolumePercent(99);
 200   VolumeUp();
 201   EXPECT_EQ(3, num_play_requests());
 202
 203   audio_handler_->SetOutputVolumePercent(100);
 204   VolumeUp();
 205   EXPECT_EQ(3, num_play_requests());
 206
 207   // Check that sound isn't played when audio is muted.
 208   audio_handler_->SetOutputVolumePercent(50);
 209   VolumeMute();
 210   VolumeDown();
 211   ASSERT_TRUE(audio_handler_->IsOutputMuted());
 212   EXPECT_EQ(3, num_play_requests());
 213
 214   // Check that audio is unmuted and sound is played.
 215   VolumeUp();
 216   ASSERT_FALSE(audio_handler_->IsOutputMuted());
 217   EXPECT_EQ(4, num_play_requests());
 218 }
 219
 220 class VolumeControllerSoundsDisabledTest : public VolumeControllerSoundsTest {
 221  public:
 222   VolumeControllerSoundsDisabledTest() {}
 223   virtual ~VolumeControllerSoundsDisabledTest() {}
 224
 225   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 226     VolumeControllerSoundsTest::SetUpCommandLine(command_line);
 227     command_line->AppendSwitch(chromeos::switches::kDisableVolumeAdjustSound);
 228   }
 229
 230  private:
 231   DISALLOW_COPY_AND_ASSIGN(VolumeControllerSoundsDisabledTest);
 232 };
 233
 234 IN_PROC_BROWSER_TEST_F(VolumeControllerSoundsDisabledTest,
 235                        VolumeAdjustSounds) {
 236   EXPECT_FALSE(is_sound_initialized());
 237
 238   // Check that sound isn't played on volume up and volume down.
 239   audio_handler_->SetOutputVolumePercent(50);
 240   VolumeUp();
 241   VolumeDown();
 242   EXPECT_EQ(0, num_play_requests());
 243 }
 244
 245 }  // namespace