Bug 836655 - Modify unit test for adapting change in this bug. r=baku

dom/audiochannel/tests/TestAudioChannelService.cpp

@@ -1,6 +1,11 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifdef XP_WIN
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
 
 #include "TestHarness.h"
 
@@ -19,19 +24,25 @@
 
 using namespace mozilla::dom;
 
-class Agent
+class Agent : public nsIAudioChannelAgentCallback
 {
 public:
+  NS_DECL_ISUPPORTS
+
   Agent(AudioChannelType aType)
   : mType(aType)
+  , mWaitCallback(false)
   , mRegistered(false)
+  , mCanPlay(false)
   {
     mAgent = do_CreateInstance("@mozilla.org/audiochannelagent;1");
   }
 
+  virtual ~Agent() {}
+
   nsresult Init()
   {
-    nsresult rv = mAgent->Init(mType, nullptr);
+    nsresult rv = mAgent->Init(mType, this);
     NS_ENSURE_SUCCESS(rv, rv);
 
     return mAgent->SetVisibilityState(false);
@@ -50,26 +61,74 @@ public:
   nsresult StopPlaying()
   {
     mRegistered = false;
+    int loop = 0;
+    while (mWaitCallback) {
+      #ifdef XP_WIN
+      Sleep(1000);
+      #else
+      sleep(1);
+      #endif
+      if (loop++ == 5) {
+        TEST_ENSURE_BASE(false, "StopPlaying timeout");
+      }
+    }
     return mAgent->StopPlaying();
   }
 
+  nsresult SetVisibilityState(bool visible)
+  {
+    if (mRegistered) {
+      mWaitCallback = true;
+    }
+    return mAgent->SetVisibilityState(visible);
+  }
+
+  NS_IMETHODIMP CanPlayChanged(bool canPlay)
+  {
+    mCanPlay = canPlay;
+    mWaitCallback = false;
+    return NS_OK;
+  }
+
+  nsresult GetCanPlay(bool *_ret)
+  {
+    int loop = 0;
+    while (mWaitCallback) {
+      #ifdef XP_WIN
+      Sleep(1000);
+      #else
+      sleep(1);
+      #endif
+      if (loop++ == 5) {
+        TEST_ENSURE_BASE(false, "GetCanPlay timeout");
+      }
+    }
+    *_ret = mCanPlay;
+    return NS_OK;
+  }
+
   nsCOMPtr<AudioChannelAgent> mAgent;
   AudioChannelType mType;
+  bool mWaitCallback;
   bool mRegistered;
+  bool mCanPlay;
 };
 
+NS_IMPL_ISUPPORTS1(Agent, nsIAudioChannelAgentCallback)
+
 nsresult
 TestDoubleStartPlaying()
 {
-  Agent agent(AUDIO_CHANNEL_NORMAL);
-  nsresult rv = agent.Init();
+  nsCOMPtr<Agent> agent = new Agent(AUDIO_CHANNEL_NORMAL);
+
+  nsresult rv = agent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool playing;
-  rv = agent.mAgent->StartPlaying(&playing);
+  rv = agent->mAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = agent.mAgent->StartPlaying(&playing);
+  rv = agent->mAgent->StartPlaying(&playing);
   TEST_ENSURE_BASE(NS_FAILED(rv), "Test0: StartPlaying calling twice should return error");
 
   return NS_OK;
@@ -78,19 +137,19 @@ TestDoubleStartPlaying()
 nsresult
 TestOneNormalChannel()
 {
-  Agent agent(AUDIO_CHANNEL_NORMAL);
-  nsresult rv = agent.Init();
+  nsCOMPtr<Agent> agent = new Agent(AUDIO_CHANNEL_NORMAL);
+  nsresult rv = agent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool playing;
-  rv = agent.StartPlaying(&playing);
+  rv = agent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test1: A normal channel unvisible agent must not be playing");
 
-  rv = agent.mAgent->SetVisibilityState(true);
+  rv = agent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = agent.StartPlaying(&playing);
+  rv = agent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test1: A normal channel visible agent should be playing");
 
@@ -100,34 +159,34 @@ TestOneNormalChannel()
 nsresult
 TestTwoNormalChannels()
 {
-  Agent agent1(AUDIO_CHANNEL_NORMAL);
-  nsresult rv = agent1.Init();
+  nsCOMPtr<Agent> agent1 = new Agent(AUDIO_CHANNEL_NORMAL);
+  nsresult rv = agent1->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent agent2(AUDIO_CHANNEL_NORMAL);
-  rv = agent2.Init();
+  nsCOMPtr<Agent> agent2 = new Agent(AUDIO_CHANNEL_NORMAL);
+  rv = agent2->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool playing;
-  rv = agent1.StartPlaying(&playing);
+  rv = agent1->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test2: A normal channel unvisible agent1 must not be playing");
 
-  rv = agent2.StartPlaying(&playing);
+  rv = agent2->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test2: A normal channel unvisible agent2 must not be playing");
 
-  rv = agent1.mAgent->SetVisibilityState(true);
+  rv = agent1->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = agent2.mAgent->SetVisibilityState(true);
+  rv = agent2->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = agent1.StartPlaying(&playing);
+  rv = agent1->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test2: A normal channel visible agent1 should be playing");
 
-  rv = agent2.StartPlaying(&playing);
+  rv = agent2->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test2: A normal channel visible agent2 should be playing");
 
@@ -137,213 +196,230 @@ TestTwoNormalChannels()
 nsresult
 TestContentChannels()
 {
-  Agent agent1(AUDIO_CHANNEL_CONTENT);
-  nsresult rv = agent1.Init();
+  nsCOMPtr<Agent> agent1 = new Agent(AUDIO_CHANNEL_CONTENT);
+  nsresult rv = agent1->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent agent2(AUDIO_CHANNEL_CONTENT);
-  rv = agent2.Init();
+  nsCOMPtr<Agent> agent2 = new Agent(AUDIO_CHANNEL_CONTENT);
+  rv = agent2->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = agent1.mAgent->SetVisibilityState(true);
+  /* All content channels in the foreground can be allowed to play */
+  rv = agent1->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = agent2.mAgent->SetVisibilityState(true);
+  rv = agent2->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool playing;
-  rv = agent1.StartPlaying(&playing);
-  NS_ENSURE_SUCCESS(rv, rv);
-  TEST_ENSURE_BASE(playing, "Test3: A content channel unvisible agent1 should be playing");
-
-  rv = agent2.StartPlaying(&playing);
-  NS_ENSURE_SUCCESS(rv, rv);
-  TEST_ENSURE_BASE(playing, "Test3: A content channel unvisible agent2 should be playing");
-
-  rv = agent1.mAgent->SetVisibilityState(true);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  rv = agent2.mAgent->SetVisibilityState(false);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  rv = agent1.StartPlaying(&playing);
+  rv = agent1->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test3: A content channel visible agent1 should be playing");
 
-  rv = agent2.StartPlaying(&playing);
-  NS_ENSURE_SUCCESS(rv, rv);
-  TEST_ENSURE_BASE(playing, "Test3: A content channel unvisible agent2 should be playing");
-
-  rv = agent1.mAgent->SetVisibilityState(true);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  rv = agent2.mAgent->SetVisibilityState(true);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  rv = agent1.StartPlaying(&playing);
-  NS_ENSURE_SUCCESS(rv, rv);
-  TEST_ENSURE_BASE(playing, "Test3: A content channel visible agent1 should be playing");
-
-  rv = agent2.StartPlaying(&playing);
+  rv = agent2->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test3: A content channel visible agent2 should be playing");
 
+  /* Test the transition state of one content channel tried to set non-visible
+   * state first when app is going to background. */
+  rv = agent1->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent1->GetCanPlay(&playing);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playing, "Test3: A content channel unvisible agent1 should be playing from foreground to background");
+
+  /* Test all content channels set non-visible already */
+  rv = agent2->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent2->GetCanPlay(&playing);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playing, "Test3: A content channel unvisible agent2 should be playing from foreground to background");
+
+  /* Clear the content channels & mActiveContentChildIDs in AudioChannelService.
+   * If agent stop playing in the background, we will reserve it's childID in
+   * mActiveContentChildIDs, then it can allow to play next song. So we set agents
+   * to foreground first then stopping to play */
+  rv = agent1->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = agent2->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = agent1->StopPlaying();
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = agent2->StopPlaying();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  /* Test that content channels can't be allow to play when they starts from the background state */
+  rv = agent1->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = agent2->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent1->StartPlaying(&playing);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(!playing, "Test3: A content channel unvisible agent1 must not be playing from background state");
+
+  rv = agent2->StartPlaying(&playing);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(!playing, "Test3: A content channel unvisible agent2 must not be playing from background state");
+
   return rv;
 }
 
 nsresult
 TestPriorities()
 {
-  Agent normalAgent(AUDIO_CHANNEL_NORMAL);
-  nsresult rv = normalAgent.Init();
+  nsCOMPtr<Agent> normalAgent = new Agent(AUDIO_CHANNEL_NORMAL);
+  nsresult rv = normalAgent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent contentAgent(AUDIO_CHANNEL_CONTENT);
-  rv = contentAgent.Init();
+  nsCOMPtr<Agent> contentAgent = new Agent(AUDIO_CHANNEL_CONTENT);
+  rv = contentAgent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent notificationAgent(AUDIO_CHANNEL_NOTIFICATION);
-  rv = notificationAgent.Init();
+  nsCOMPtr<Agent> notificationAgent = new Agent(AUDIO_CHANNEL_NOTIFICATION);
+  rv = notificationAgent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent alarmAgent(AUDIO_CHANNEL_ALARM);
-  rv = alarmAgent.Init();
+  nsCOMPtr<Agent> alarmAgent = new Agent(AUDIO_CHANNEL_ALARM);
+  rv = alarmAgent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent telephonyAgent(AUDIO_CHANNEL_TELEPHONY);
-  rv = telephonyAgent.Init();
+  nsCOMPtr<Agent> telephonyAgent = new Agent(AUDIO_CHANNEL_TELEPHONY);
+  rv = telephonyAgent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent ringerAgent(AUDIO_CHANNEL_RINGER);
-  rv = ringerAgent.Init();
+  nsCOMPtr<Agent> ringerAgent = new Agent(AUDIO_CHANNEL_RINGER);
+  rv = ringerAgent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  Agent pNotificationAgent(AUDIO_CHANNEL_PUBLICNOTIFICATION);
-  rv = pNotificationAgent.Init();
+  nsCOMPtr<Agent> pNotificationAgent = new Agent(AUDIO_CHANNEL_PUBLICNOTIFICATION);
+  rv = pNotificationAgent->Init();
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool playing;
 
   // Normal should not be playing because not visible.
-  rv = normalAgent.StartPlaying(&playing);
+  rv = normalAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
-  TEST_ENSURE_BASE(!playing, "Test4: A normal channel unvisible agent should not be playing");
+  TEST_ENSURE_BASE(!playing, "Test4: A normal channel unvisible agent must not be playing");
 
   // Content should be playing.
-  rv = contentAgent.StartPlaying(&playing);
+  rv = contentAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
-  TEST_ENSURE_BASE(playing, "Test4: A content channel unvisible agent should be playing");
+  TEST_ENSURE_BASE(!playing, "Test4: A content channel unvisible agent must not be playing from background state");
 
   // Notification should be playing.
-  rv = notificationAgent.StartPlaying(&playing);
+  rv = notificationAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: An notification channel unvisible agent should be playing");
 
   // Now content should be not playing because of the notification playing.
-  rv = contentAgent.StartPlaying(&playing);
+  rv = contentAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test4: A content channel unvisible agent should not be playing when notification channel is playing");
 
   // Adding an alarm.
-  rv = alarmAgent.StartPlaying(&playing);
+  rv = alarmAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: An alarm channel unvisible agent should be playing");
 
   // Now notification should be not playing because of the alarm playing.
-  rv = notificationAgent.StartPlaying(&playing);
+  rv = notificationAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test4: A notification channel unvisible agent should not be playing when an alarm is playing");
 
   // Adding an telephony.
-  rv = telephonyAgent.StartPlaying(&playing);
+  rv = telephonyAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: An telephony channel unvisible agent should be playing");
 
   // Now alarm should be not playing because of the telephony playing.
-  rv = alarmAgent.StartPlaying(&playing);
+  rv = alarmAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test4: A alarm channel unvisible agent should not be playing when a telephony is playing");
 
   // Adding an ringer.
-  rv = ringerAgent.StartPlaying(&playing);
+  rv = ringerAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: An ringer channel unvisible agent should be playing");
 
   // Now telephony should be not playing because of the ringer playing.
-  rv = telephonyAgent.StartPlaying(&playing);
+  rv = telephonyAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test4: A telephony channel unvisible agent should not be playing when a riger is playing");
 
   // Adding an pNotification.
-  rv = pNotificationAgent.StartPlaying(&playing);
+  rv = pNotificationAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: An pNotification channel unvisible agent should be playing");
 
   // Now ringer should be not playing because of the public notification playing.
-  rv = ringerAgent.StartPlaying(&playing);
+  rv = ringerAgent->StartPlaying(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(!playing, "Test4: A ringer channel unvisible agent should not be playing when a public notification is playing");
 
   // Settings visible the normal channel.
-  rv = normalAgent.mAgent->SetVisibilityState(true);
+  rv = normalAgent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Normal should be playing because visible.
-  rv = normalAgent.StartPlaying(&playing);
+  rv = normalAgent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: A normal channel visible agent should be playing");
 
   // Settings visible the content channel.
-  rv = contentAgent.mAgent->SetVisibilityState(true);
+  rv = contentAgent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Content should be playing because visible.
-  rv = contentAgent.StartPlaying(&playing);
+  rv = contentAgent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: A content channel visible agent should be playing");
 
   // Settings visible the notification channel.
-  rv = notificationAgent.mAgent->SetVisibilityState(true);
+  rv = notificationAgent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Notification should be playing because visible.
-  rv = notificationAgent.StartPlaying(&playing);
+  rv = notificationAgent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: A notification channel visible agent should be playing");
 
   // Settings visible the alarm channel.
-  rv = alarmAgent.mAgent->SetVisibilityState(true);
+  rv = alarmAgent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Alarm should be playing because visible.
-  rv = alarmAgent.StartPlaying(&playing);
+  rv = alarmAgent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: A alarm channel visible agent should be playing");
 
   // Settings visible the telephony channel.
-  rv = telephonyAgent.mAgent->SetVisibilityState(true);
+  rv = telephonyAgent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Telephony should be playing because visible.
-  rv = telephonyAgent.StartPlaying(&playing);
+  rv = telephonyAgent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: A telephony channel visible agent should be playing");
 
   // Settings visible the ringer channel.
-  rv = ringerAgent.mAgent->SetVisibilityState(true);
+  rv = ringerAgent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Ringer should be playing because visible.
-  rv = ringerAgent.StartPlaying(&playing);
+  rv = ringerAgent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: A ringer channel visible agent should be playing");
 
   // Settings visible the pNotification channel.
-  rv = pNotificationAgent.mAgent->SetVisibilityState(true);
+  rv = pNotificationAgent->SetVisibilityState(true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // pNotification should be playing because visible.
-  rv = pNotificationAgent.StartPlaying(&playing);
+  rv = pNotificationAgent->GetCanPlay(&playing);
   NS_ENSURE_SUCCESS(rv, rv);
   TEST_ENSURE_BASE(playing, "Test4: A pNotification channel visible agent should be playing");