fixup! [WebRTC] Deadlock when creating SwitchableVideoEncoder

Updating UnitTests AudioPreferenceTest, to use fact that
`SuspendResumeSevice` uses `base::NoDestructor` instead of
singleton.

Bug: https://jira-eu.sec.samsung.net/browse/VDWASM-1942
Change-Id: I66934fe828d0d215c3ff1c5e3744cea06215da92

diff --git a/tizen_src/chromium_impl/media/audio/tizen/mch_pcm_with_software_fallback_output_test.cc b/tizen_src/chromium_impl/media/audio/tizen/mch_pcm_with_software_fallback_output_test.cc
index 18f7c8938e82ac4f5104f46355b87ef719ccaeac..517637d0ed48648d8365a417f342a12fdd31f9bf 100644 (file)
--- a/tizen_src/chromium_impl/media/audio/tizen/mch_pcm_with_software_fallback_output_test.cc
+++ b/tizen_src/chromium_impl/media/audio/tizen/mch_pcm_with_software_fallback_output_test.cc
@@ -204,9 +204,6 @@ class MchPcmSoftwareFallbackOutputTest : public testing::Test {
  protected:
   base::test::TaskEnvironment task_environment_{
       base::test::TaskEnvironment::TimeSource::MOCK_TIME};
-
- private:
-  base::ShadowingAtExitManager at_exit_;
 };
 
 TEST_F(MchPcmSoftwareFallbackOutputTest, CreateDisabled) {

diff --git a/tizen_src/chromium_impl/services/audio_preference/public/cpp/audio_preference_test.cc b/tizen_src/chromium_impl/services/audio_preference/public/cpp/audio_preference_test.cc
index c33633bc5093617e5567e863e66cc1a54b14c7e7..8de14c56eed72936183fdff240b56c0b4dc210a5 100644 (file)
--- a/tizen_src/chromium_impl/services/audio_preference/public/cpp/audio_preference_test.cc
+++ b/tizen_src/chromium_impl/services/audio_preference/public/cpp/audio_preference_test.cc
@@ -4,22 +4,14 @@
 
 #include "services/audio_preference/public/cpp/audio_preference.h"
 
-#include "base/at_exit.h"
 #include "services/audio_preference/audio_preference_service_impl.h"
 #include "services/suspend_resume/public/cpp/suspend_resume.h"
+#include "services/suspend_resume/suspend_resume_service_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace audio_preference {
 
-// Note that we run method directly on service, not on singleton instance,
-// because there were issues with properly clearing singleton state when
-// running tests in single process.
-//
-// Despite having AtExitManager set up, sometimes state was preserved between
-// tests leading other one to randomly fail.
-// Note: it happened only when calling |SetHardwareAudioDisabled|.
-
 class MockAudioHardwarePreferenceObserver
     : public AudioHardwarePreferenceObserver {
  public:
@@ -29,76 +21,96 @@ class MockAudioHardwarePreferenceObserver
   MOCK_METHOD(void, AudioHardwarePreferenceChanged, (AudioHardwarePreference));
 };
 
-class LocalAudioPreferenceService : public AudioPreferenceServiceImpl {};
+class LocalAudioPreferenceService : public AudioPreferenceServiceImpl {
+ public:
+  LocalAudioPreferenceService() {
+    AudioPreferenceServiceImpl::OverrideInstanceForTesting(this);
+  }
+
+  ~LocalAudioPreferenceService() override {
+    AudioPreferenceServiceImpl::OverrideInstanceForTesting(nullptr);
+  }
+};
+
+class LocalSuspendResumeService
+    : public suspend_resume::SuspendResumeServiceImpl {
+ public:
+  LocalSuspendResumeService() {
+    SuspendResumeServiceImpl::OverrideInstanceForTesting(this);
+  }
+
+  ~LocalSuspendResumeService() {
+    SuspendResumeServiceImpl::OverrideInstanceForTesting(nullptr);
+  }
+};
 
 class AudioPreferenceTest : public testing::Test {
- private:
-  // Ensure that we'll get fresh singleton every time.
-  base::ShadowingAtExitManager at_exit_;
+ protected:
+  void SetUp() override {
+    ASSERT_EQ(AudioPreferenceServiceImpl::GetInstance(), &service_);
+    ASSERT_EQ(suspend_resume::SuspendResumeServiceImpl::GetInstance(),
+              &suspend_resume_service_);
+  }
+
+  LocalSuspendResumeService suspend_resume_service_;
+  LocalAudioPreferenceService service_;
 };
 
 TEST_F(AudioPreferenceTest, MightUseHardwareOnStart) {
-  LocalAudioPreferenceService service;
   MockAudioHardwarePreferenceObserver observer;
 
-  EXPECT_EQ(service.RegisterObserver(&observer),
+  EXPECT_EQ(audio_preference::AddObserver(&observer),
             AudioHardwarePreference::HARDWARE);
 }
 
 TEST_F(AudioPreferenceTest, HardwareWhenStartingResumed) {
-  LocalAudioPreferenceService service;
   MockAudioHardwarePreferenceObserver observer;
 
   suspend_resume::NotifyStateChange(suspend_resume::State::RESUMED);
-  EXPECT_EQ(service.RegisterObserver(&observer),
+  EXPECT_EQ(audio_preference::AddObserver(&observer),
             AudioHardwarePreference::HARDWARE);
 }
 
 TEST_F(AudioPreferenceTest, SoftwareWhenStartingInPartialView) {
-  LocalAudioPreferenceService service;
   MockAudioHardwarePreferenceObserver observer;
 
   suspend_resume::NotifyStateChange(suspend_resume::State::PARTIAL);
-  EXPECT_EQ(service.RegisterObserver(&observer),
+  EXPECT_EQ(audio_preference::AddObserver(&observer),
             AudioHardwarePreference::SOFTWARE);
 }
 
 TEST_F(AudioPreferenceTest, DisabledWhenStartingSuspended) {
-  LocalAudioPreferenceService service;
   MockAudioHardwarePreferenceObserver observer;
 
   suspend_resume::NotifyStateChange(suspend_resume::State::SUSPENDED);
-  EXPECT_EQ(service.RegisterObserver(&observer),
+  EXPECT_EQ(audio_preference::AddObserver(&observer),
             AudioHardwarePreference::DISABLED);
 }
 
 TEST_F(AudioPreferenceTest, ObserverReceivesNotificationSoftwareInPartial) {
-  LocalAudioPreferenceService service;
   MockAudioHardwarePreferenceObserver observer;
 
-  ASSERT_EQ(service.RegisterObserver(&observer),
+  ASSERT_EQ(audio_preference::AddObserver(&observer),
             AudioHardwarePreference::HARDWARE);
   EXPECT_CALL(observer, AudioHardwarePreferenceChanged(
                             AudioHardwarePreference::SOFTWARE));
   suspend_resume::NotifyStateChange(suspend_resume::State::PARTIAL);
 }
 
-TEST_F(AudioPreferenceTest, ObserverIsNotNotifedAfterRemoving) {
-  LocalAudioPreferenceService service;
+TEST_F(AudioPreferenceTest, ObserverIsNotNotifiedAfterRemoving) {
   MockAudioHardwarePreferenceObserver observer;
   EXPECT_CALL(observer, AudioHardwarePreferenceChanged(testing::_)).Times(0);
 
-  ASSERT_EQ(service.RegisterObserver(&observer),
+  ASSERT_EQ(audio_preference::AddObserver(&observer),
             AudioHardwarePreference::HARDWARE);
-  service.RemoveObserver(&observer);
+  audio_preference::RemoveObserver(&observer);
   suspend_resume::NotifyStateChange(suspend_resume::State::PARTIAL);
 }
 
 TEST_F(AudioPreferenceTest, ObserverReceivesNotificationDisabledWhenSuspended) {
-  LocalAudioPreferenceService service;
   MockAudioHardwarePreferenceObserver observer;
 
-  ASSERT_EQ(service.RegisterObserver(&observer),
+  ASSERT_EQ(audio_preference::AddObserver(&observer),
             AudioHardwarePreference::HARDWARE);
   EXPECT_CALL(observer, AudioHardwarePreferenceChanged(
                             AudioHardwarePreference::DISABLED));
@@ -106,34 +118,30 @@ TEST_F(AudioPreferenceTest, ObserverReceivesNotificationDisabledWhenSuspended) {
 }
 
 TEST_F(AudioPreferenceTest, GetRegisterExternalAudioDevice) {
-  LocalAudioPreferenceService service;
-  EXPECT_TRUE(service.RegisterExternalAudioDevice());
+  EXPECT_TRUE(audio_preference::RegisterExternalAudioDevice());
 }
 
-TEST_F(AudioPreferenceTest,
-       NewObserverGetsSoftawareWhenRegisterExternalDevice) {
-  LocalAudioPreferenceService service;
-  auto token = service.RegisterExternalAudioDevice();
+TEST_F(AudioPreferenceTest, NewObserverGetsSoftwareWhenRegisterExternalDevice) {
+  auto token = audio_preference::RegisterExternalAudioDevice();
   ASSERT_TRUE(token);
   {
     MockAudioHardwarePreferenceObserver observer;
-    EXPECT_EQ(service.RegisterObserver(&observer),
+    EXPECT_EQ(audio_preference::AddObserver(&observer),
               AudioHardwarePreference::SOFTWARE);
   }
   // Ensure that dangling observer is not called.
   std::ignore = token.Release();
 }
 
-TEST_F(AudioPreferenceTest, ObserverGetsSoftawareWhenRegisterExternalDevice) {
-  LocalAudioPreferenceService service;
+TEST_F(AudioPreferenceTest, ObserverGetsSoftwareWhenRegisterExternalDevice) {
   ExternalAudioDeviceToken token;
   {
     MockAudioHardwarePreferenceObserver observer;
-    ASSERT_EQ(service.RegisterObserver(&observer),
+    ASSERT_EQ(audio_preference::AddObserver(&observer),
               AudioHardwarePreference::HARDWARE);
     EXPECT_CALL(observer, AudioHardwarePreferenceChanged(
                               AudioHardwarePreference::SOFTWARE));
-    token = service.RegisterExternalAudioDevice();
+    token = audio_preference::RegisterExternalAudioDevice();
     ASSERT_TRUE(token);
   }
   // Ensure that dangling observer is not called.
@@ -141,12 +149,12 @@ TEST_F(AudioPreferenceTest, ObserverGetsSoftawareWhenRegisterExternalDevice) {
 }
 
 TEST_F(AudioPreferenceTest, ObserverGetsHardwareAfterReleaseExternalDevice) {
-  LocalAudioPreferenceService service;
   MockAudioHardwarePreferenceObserver observer;
   {
-    ExternalAudioDeviceToken token = service.RegisterExternalAudioDevice();
+    ExternalAudioDeviceToken token =
+        audio_preference::RegisterExternalAudioDevice();
     ASSERT_TRUE(token);
-    ASSERT_EQ(service.RegisterObserver(&observer),
+    ASSERT_EQ(audio_preference::AddObserver(&observer),
               AudioHardwarePreference::SOFTWARE);
     EXPECT_CALL(observer, AudioHardwarePreferenceChanged(
                               AudioHardwarePreference::HARDWARE));

diff --git a/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.cc b/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.cc
index 27f32affef7e008d0dac087fcf09ef3361fdbcac..53641d246e0db0f25f735175c3e8e882d715dcd9 100644 (file)
--- a/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.cc
+++ b/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.cc
@@ -6,8 +6,16 @@
 
 namespace suspend_resume {
 
+namespace {
+static SuspendResumeServiceImpl* service_for_testing = nullptr;
+}  // namespace
+
 // static
 SuspendResumeServiceImpl* SuspendResumeServiceImpl::GetInstance() {
+  if (service_for_testing) {
+    return service_for_testing;
+  }
+
   static base::NoDestructor<SuspendResumeServiceImpl> instance;
   return instance.get();
 }
@@ -67,4 +75,10 @@ void SuspendResumeServiceImpl::AddObserver(
   std::move(callback).Run(last_state_);
 }
 
+// static
+void SuspendResumeServiceImpl::OverrideInstanceForTesting(
+    SuspendResumeServiceImpl* service_instance_for_testing) {
+  service_for_testing = service_instance_for_testing;
+}
+
 }  // namespace suspend_resume

diff --git a/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.h b/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.h
index 18430bd34248f67962300e4df8c60f16570a2594..2967e57134d86fbb8704d72b419a633d8d4934b1 100644 (file)
--- a/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.h
+++ b/tizen_src/chromium_impl/services/suspend_resume/suspend_resume_service_impl.h
@@ -36,9 +36,13 @@ class SuspendResumeServiceImpl : public mojom::SuspendResumeManager {
       mojo::PendingRemote<mojom::SuspendResumeObserver> pending_observer,
       AddObserverCallback callback) override;
 
- private:
+ protected:
+  static void OverrideInstanceForTesting(
+      SuspendResumeServiceImpl* service_instance_for_testing);
+
   SuspendResumeServiceImpl() = default;
 
+ private:
   base::Lock lock_;
   absl::optional<mojom::State> last_state_ GUARDED_BY(lock_);
   std::unordered_set<mojom::SuspendResumeObserver*> clients_ GUARDED_BY(lock_);