Fix Volume slider is captured in screenshot done in touchview mode

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 <memory>
@@ skipping 403 matching lines @@
   }
 
   void SetHDMIRediscoverGracePeriodDuration(int duration_in_ms) {
     cras_audio_handler_->SetHDMIRediscoverGracePeriodForTesting(duration_in_ms);
   }
 
   bool IsDuringHDMIRediscoverGracePeriod() {
     return cras_audio_handler_->hdmi_rediscovering();
   }
 
+  // Simulating CrasAudioHandler::SetupAudioOutputState during initializing
+  // audio state by using fake_cras_audio_client_ to SetOutputNodeVolume,
+  // so that we can disable the auto OutputNodeVolumeChanged signal.
+  void SetupAudioOutputStateDuringInitialization() {
+    cras_audio_handler_->initializing_audio_state_ = true;
+    uint64_t active_output_node_id =
+        cras_audio_handler_->GetPrimaryActiveOutputNode();
+    int output_volume = cras_audio_handler_->GetOutputVolumePercent();
+    cras_audio_handler_->init_node_id_ = active_output_node_id;

[Daniel Erat, 2016/08/04 23:08:59]

please don't reach directly into the object being tested and set its members
like this. it results in tests that need to be updated whenever the class's
implementation is changed, and that may not be testing the way that things
actually work in production.

is there no way to get CrasAudioHandler into the correct state by calling its
public methods, as would happen during initialization?

[Qiang(Joe) Xu, 2016/08/04 23:41:03]

Sorry wrong local branch.

+    cras_audio_handler_->init_volume_ = output_volume;
+    cras_audio_handler_->automated_volume_change_reasons_.push_back(
+        CrasAudioHandler::VOLUME_CHANGE_INITIALIZING_AUDIO_STATE);
+    fake_cras_audio_client_->SetOutputNodeVolume(active_output_node_id,
+                                                 output_volume);
+  }
+
  protected:
   base::MessageLoopForUI message_loop_;
   CrasAudioHandler* cras_audio_handler_;  // Not owned.
   FakeCrasAudioClient* fake_cras_audio_client_;  // Not owned.
   std::unique_ptr<TestObserver> test_observer_;
   scoped_refptr<AudioDevicesPrefHandlerStub> audio_pref_handler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CrasAudioHandlerTest);
 };
@@ skipping 1531 matching lines @@
   EXPECT_FALSE(cras_audio_handler_->IsInputMuted());
   EXPECT_EQ(2, test_observer_->input_mute_changed_count());
 }
 
 TEST_F(CrasAudioHandlerTest, SetOutputVolumePercent) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalSpeaker);
   SetUpCrasAudioHandler(audio_nodes);
   EXPECT_EQ(0, test_observer_->output_volume_changed_count());
 
-  cras_audio_handler_->SetOutputVolumePercent(60);
+  const int kVolume = 60;
+  cras_audio_handler_->SetOutputVolumePercent(kVolume);
 
   // Verify the output volume is changed to the designated value,
   // OnOutputNodeVolumeChanged event is fired, and the device volume value
-  // is saved the preferences.
-  const int kVolume = 60;
+  // is saved in the preferences.
   EXPECT_EQ(kVolume, cras_audio_handler_->GetOutputVolumePercent());
   EXPECT_EQ(1, test_observer_->output_volume_changed_count());
   AudioDevice device;
   EXPECT_TRUE(cras_audio_handler_->GetPrimaryActiveOutputDevice(&device));
   EXPECT_EQ(device.id, kInternalSpeaker.id);
   EXPECT_EQ(kVolume, audio_pref_handler_->GetOutputVolumeValue(&device));
 }
 
+TEST_F(CrasAudioHandlerTest, SetOutputVolumePercentWithoutNotifyingObservers) {
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  SetUpCrasAudioHandler(audio_nodes);
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+
+  const int kVolume1 = 60;
+  const int kVolume2 = 80;
+  cras_audio_handler_->SetOutputVolumePercentWithoutNotifyingObservers(
+      kVolume1, CrasAudioHandler::VOLUME_CHANGE_MAXIMIZE_MODE_SCREENSHOT);
+  // Verify the output volume is changed to the designated value,
+  // OnOutputNodeVolumeChanged event is not fired, and the device volume value
+  // is saved in the preferences.
+  EXPECT_EQ(kVolume1, cras_audio_handler_->GetOutputVolumePercent());
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+  AudioDevice device;
+  EXPECT_TRUE(cras_audio_handler_->GetPrimaryActiveOutputDevice(&device));
+  EXPECT_EQ(device.id, kInternalSpeaker.id);
+  EXPECT_EQ(kVolume1, audio_pref_handler_->GetOutputVolumeValue(&device));
+
+  // Make another SetOutputVolumePercentWithoutNotifyingObservers call to make
+  // sure everything is right.
+  cras_audio_handler_->SetOutputVolumePercentWithoutNotifyingObservers(
+      kVolume2, CrasAudioHandler::VOLUME_CHANGE_MAXIMIZE_MODE_SCREENSHOT);
+  EXPECT_EQ(kVolume2, cras_audio_handler_->GetOutputVolumePercent());
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+  EXPECT_TRUE(cras_audio_handler_->GetPrimaryActiveOutputDevice(&device));
+  EXPECT_EQ(device.id, kInternalSpeaker.id);
+  EXPECT_EQ(kVolume2, audio_pref_handler_->GetOutputVolumeValue(&device));
+
+  // Make a final SetOutputVolumePercent call to check if
+  // SetOutputVolumePercentWithoutNotifyingObservers may block subsequent
+  // notifying observers.
+  cras_audio_handler_->SetOutputVolumePercent(kVolume1);
+  EXPECT_EQ(kVolume1, cras_audio_handler_->GetOutputVolumePercent());
+  EXPECT_EQ(1, test_observer_->output_volume_changed_count());
+  EXPECT_TRUE(cras_audio_handler_->GetPrimaryActiveOutputDevice(&device));
+  EXPECT_EQ(device.id, kInternalSpeaker.id);
+  EXPECT_EQ(kVolume1, audio_pref_handler_->GetOutputVolumeValue(&device));
+}
+
+TEST_F(CrasAudioHandlerTest,
+       SetupAudioOutputStateDuringInitializationWithCrasReady) {
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  SetUpCrasAudioHandler(audio_nodes);
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+
+  const int kDefaultVolume = 75;
+  EXPECT_EQ(kDefaultVolume, cras_audio_handler_->GetOutputVolumePercent());
+
+  // Disable the auto OutputNodeVolumeChanged signal.
+  fake_cras_audio_client_->set_notify_volume_change_with_delay(true);
+
+  SetupAudioOutputStateDuringInitialization();
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+  EXPECT_EQ(kDefaultVolume, cras_audio_handler_->GetOutputVolumePercent());
+
+  // The correct initialization OutputNodeVolumeChanged event is fired. We
+  // should avoid notify observers.
+  fake_cras_audio_client_->NotifyOutputNodeVolumeChangedForTesting(
+      kInternalSpeaker.id, kDefaultVolume);
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+  EXPECT_EQ(kDefaultVolume, cras_audio_handler_->GetOutputVolumePercent());
+
+  // The later OutputNodeVolumeChanged event after initialization should notify
+  // observers.
+  const int kVolume = 60;
+  fake_cras_audio_client_->NotifyOutputNodeVolumeChangedForTesting(
+      kInternalSpeaker.id, kVolume);
+  EXPECT_EQ(1, test_observer_->output_volume_changed_count());
+  EXPECT_EQ(kVolume, cras_audio_handler_->GetOutputVolumePercent());
+}
+
+TEST_F(CrasAudioHandlerTest,
+       SetupAudioOutputStateDuringInitializationWithCrasDropRequest) {
+  AudioNodeList audio_nodes;
+  audio_nodes.push_back(kInternalSpeaker);
+  SetUpCrasAudioHandler(audio_nodes);
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+
+  const int kDefaultVolume = 75;
+  EXPECT_EQ(kDefaultVolume, cras_audio_handler_->GetOutputVolumePercent());
+
+  // Disable the auto OutputNodeVolumeChanged signal.
+  fake_cras_audio_client_->set_notify_volume_change_with_delay(true);
+
+  SetupAudioOutputStateDuringInitialization();
+  EXPECT_EQ(0, test_observer_->output_volume_changed_count());
+  EXPECT_EQ(kDefaultVolume, cras_audio_handler_->GetOutputVolumePercent());
+
+  // A wrong initialization OutputNodeVolumeChanged event is fired. This may
+  // happen when Cras is not ready and drops request. The approach we use is
+  // to log warning message, clear the penging automated volume change reasons,
+  // and notify observers about this change.
+  const int kVolume1 = 30;
+  fake_cras_audio_client_->NotifyOutputNodeVolumeChangedForTesting(
+      kInternalSpeaker.id, kVolume1);
+  EXPECT_EQ(1, test_observer_->output_volume_changed_count());
+  EXPECT_EQ(kVolume1, cras_audio_handler_->GetOutputVolumePercent());
+
+  // The later OutputNodeVolumeChanged event should notify observers.
+  const int kVolume2 = 60;
+  fake_cras_audio_client_->NotifyOutputNodeVolumeChangedForTesting(
+      kInternalSpeaker.id, kVolume2);
+  EXPECT_EQ(2, test_observer_->output_volume_changed_count());
+  EXPECT_EQ(kVolume2, cras_audio_handler_->GetOutputVolumePercent());
+}
+
 TEST_F(CrasAudioHandlerTest, SetOutputVolumeWithDelayedSignal) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalSpeaker);
   SetUpCrasAudioHandler(audio_nodes);
   EXPECT_EQ(0, test_observer_->output_volume_changed_count());
 
   const int kDefaultVolume = 75;
   EXPECT_EQ(kDefaultVolume, cras_audio_handler_->GetOutputVolumePercent());
 
   // Disable the auto OutputNodeVolumeChanged signal.
@@ skipping 1294 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