diff --git a/browser/installer/package-manifest.in b/browser/installer/package-manifest.in
index 52ea0892981..42710fc079c 100644
--- a/browser/installer/package-manifest.in
+++ b/browser/installer/package-manifest.in
@@ -888,8 +888,6 @@ bin/libfreebl_32int64_3.so
 @RESPATH@/components/DataStoreImpl.js
 @RESPATH@/components/dom_datastore.xpt
 
-@RESPATH@/components/dom_audiochannel.xpt
-
 ; Shutdown Terminator
 @RESPATH@/components/nsTerminatorTelemetry.js
 @RESPATH@/components/terminator.manifest
diff --git a/dom/audiochannel/AudioChannelAgent.cpp b/dom/audiochannel/AudioChannelAgent.cpp
index 31b3146de12..aaef0c336e6 100644
--- a/dom/audiochannel/AudioChannelAgent.cpp
+++ b/dom/audiochannel/AudioChannelAgent.cpp
@@ -5,6 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "AudioChannelAgent.h"
+#include "AudioChannelCommon.h"
 #include "AudioChannelService.h"
 #include "nsIDOMWindow.h"
 #include "nsPIDOMWindow.h"
@@ -25,6 +26,8 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(AudioChannelAgent)
 AudioChannelAgent::AudioChannelAgent()
   : mAudioChannelType(AUDIO_AGENT_CHANNEL_ERROR)
   , mIsRegToService(false)
+  , mVisible(true)
+  , mWithVideo(false)
 {
 }
 
@@ -63,10 +66,21 @@ AudioChannelAgent::InitWithWeakCallback(nsIDOMWindow* aWindow,
                       /* useWeakRef = */ true);
 }
 
+/* void initWithVideo(in nsIDOMWindow window, in long channelType,
+ *                    in nsIAudioChannelAgentCallback callback, in boolean weak); */
+NS_IMETHODIMP
+AudioChannelAgent::InitWithVideo(nsIDOMWindow* aWindow, int32_t aChannelType,
+                                 nsIAudioChannelAgentCallback *aCallback,
+                                 bool aUseWeakRef)
+{
+  return InitInternal(aWindow, aChannelType, aCallback, aUseWeakRef,
+                      /* withVideo = */ true);
+}
+
 nsresult
 AudioChannelAgent::InitInternal(nsIDOMWindow* aWindow, int32_t aChannelType,
                                 nsIAudioChannelAgentCallback *aCallback,
-                                bool aUseWeakRef)
+                                bool aUseWeakRef, bool aWithVideo)
 {
   // We syncd the enum of channel type between nsIAudioChannelAgent.idl and
   // AudioChannelBinding.h the same.
@@ -86,12 +100,12 @@ AudioChannelAgent::InitInternal(nsIDOMWindow* aWindow, int32_t aChannelType,
   }
 
   if (aWindow) {
-    nsCOMPtr<nsIDOMWindow> topWindow;
-    aWindow->GetScriptableTop(getter_AddRefs(topWindow));
-    MOZ_ASSERT(topWindow);
+    nsCOMPtr<nsPIDOMWindow> pWindow = do_QueryInterface(aWindow);
+    if (!pWindow->IsInnerWindow()) {
+      pWindow = pWindow->GetCurrentInnerWindow();
+    }
 
-    mWindow = do_QueryInterface(topWindow);
-    mWindow = mWindow->GetOuterWindow();
+    mWindow = pWindow.forget();
   }
 
   mAudioChannelType = aChannelType;
@@ -102,26 +116,23 @@ AudioChannelAgent::InitInternal(nsIDOMWindow* aWindow, int32_t aChannelType,
     mCallback = aCallback;
   }
 
+  mWithVideo = aWithVideo;
+
   return NS_OK;
 }
 
 /* boolean startPlaying (); */
-NS_IMETHODIMP AudioChannelAgent::StartPlaying(float *aVolume, bool* aMuted)
+NS_IMETHODIMP AudioChannelAgent::StartPlaying(int32_t *_retval)
 {
-  MOZ_ASSERT(aVolume);
-  MOZ_ASSERT(aMuted);
-
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  AudioChannelService *service = AudioChannelService::GetOrCreateAudioChannelService();
   if (mAudioChannelType == AUDIO_AGENT_CHANNEL_ERROR ||
       service == nullptr || mIsRegToService) {
     return NS_ERROR_FAILURE;
   }
 
   service->RegisterAudioChannelAgent(this,
-    static_cast<AudioChannel>(mAudioChannelType));
-
-  service->GetState(mWindow, mAudioChannelType, aVolume, aMuted);
-
+    static_cast<AudioChannel>(mAudioChannelType), mWithVideo);
+  *_retval = service->GetState(this, !mVisible);
   mIsRegToService = true;
   return NS_OK;
 }
@@ -134,12 +145,36 @@ NS_IMETHODIMP AudioChannelAgent::StopPlaying(void)
     return NS_ERROR_FAILURE;
   }
 
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  AudioChannelService *service = AudioChannelService::GetOrCreateAudioChannelService();
   service->UnregisterAudioChannelAgent(this);
   mIsRegToService = false;
   return NS_OK;
 }
 
+/* void setVisibilityState (in boolean visible); */
+NS_IMETHODIMP AudioChannelAgent::SetVisibilityState(bool visible)
+{
+  bool oldVisibility = mVisible;
+
+  nsCOMPtr<nsIAudioChannelAgentCallback> callback = GetCallback();
+
+  mVisible = visible;
+  if (mIsRegToService && oldVisibility != mVisible && callback) {
+    AudioChannelService *service = AudioChannelService::GetOrCreateAudioChannelService();
+    callback->CanPlayChanged(service->GetState(this, !mVisible));
+  }
+  return NS_OK;
+}
+
+void AudioChannelAgent::NotifyAudioChannelStateChanged()
+{
+  nsCOMPtr<nsIAudioChannelAgentCallback> callback = GetCallback();
+  if (callback) {
+    AudioChannelService *service = AudioChannelService::GetOrCreateAudioChannelService();
+    callback->CanPlayChanged(service->GetState(this, !mVisible));
+  }
+}
+
 already_AddRefed<nsIAudioChannelAgentCallback>
 AudioChannelAgent::GetCallback()
 {
@@ -158,17 +193,20 @@ AudioChannelAgent::WindowVolumeChanged()
     return;
   }
 
-  float volume = 1.0;
-  bool muted = false;
-
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
-  service->GetState(mWindow, mAudioChannelType, &volume, &muted);
-
-  callback->WindowVolumeChanged(volume, muted);
+  callback->WindowVolumeChanged();
 }
 
-uint64_t
-AudioChannelAgent::WindowID() const
+NS_IMETHODIMP
+AudioChannelAgent::GetWindowVolume(float* aVolume)
 {
-  return mWindow ? mWindow->WindowID() : 0;
+  NS_ENSURE_ARG_POINTER(aVolume);
+
+  nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(mWindow);
+  if (!win) {
+    *aVolume = 1.0f;
+    return NS_OK;
+  }
+
+  *aVolume = win->GetAudioGlobalVolume();
+  return NS_OK;
 }
diff --git a/dom/audiochannel/AudioChannelAgent.h b/dom/audiochannel/AudioChannelAgent.h
index ed70c7e3b22..f2259386f6d 100644
--- a/dom/audiochannel/AudioChannelAgent.h
+++ b/dom/audiochannel/AudioChannelAgent.h
@@ -17,7 +17,7 @@
 #define NS_AUDIOCHANNELAGENT_CID {0xf27688e2, 0x3dd7, 0x11e2, \
       {0x90, 0x4e, 0x10, 0xbf, 0x48, 0xd6, 0x4b, 0xd4}}
 
-class nsPIDOMWindow;
+class nsIDOMWindow;
 
 namespace mozilla {
 namespace dom {
@@ -32,16 +32,15 @@ public:
   NS_DECL_CYCLE_COLLECTION_CLASS(AudioChannelAgent)
 
   AudioChannelAgent();
+  virtual void NotifyAudioChannelStateChanged();
 
   void WindowVolumeChanged();
 
-  nsPIDOMWindow* Window() const
+  nsIDOMWindow* Window() const
   {
     return mWindow;
   }
 
-  uint64_t WindowID() const;
-
 private:
   virtual ~AudioChannelAgent();
 
@@ -51,15 +50,15 @@ private:
 
   nsresult InitInternal(nsIDOMWindow* aWindow, int32_t aAudioAgentType,
                         nsIAudioChannelAgentCallback* aCallback,
-                        bool aUseWeakRef);
+                        bool aUseWeakRef, bool aWithVideo=false);
 
-  nsCOMPtr<nsPIDOMWindow> mWindow;
+  nsCOMPtr<nsIDOMWindow> mWindow;
   nsCOMPtr<nsIAudioChannelAgentCallback> mCallback;
-
   nsWeakPtr mWeakCallback;
-
   int32_t mAudioChannelType;
   bool mIsRegToService;
+  bool mVisible;
+  bool mWithVideo;
 };
 
 } // namespace dom
diff --git a/dom/audiochannel/AudioChannelCommon.h b/dom/audiochannel/AudioChannelCommon.h
new file mode 100644
index 00000000000..b0de2904140
--- /dev/null
+++ b/dom/audiochannel/AudioChannelCommon.h
@@ -0,0 +1,24 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_audiochannelcommon_h__
+#define mozilla_dom_audiochannelcommon_h__
+
+namespace mozilla {
+namespace dom {
+
+enum AudioChannelState {
+  AUDIO_CHANNEL_STATE_NORMAL = 0,
+  AUDIO_CHANNEL_STATE_MUTED,
+  AUDIO_CHANNEL_STATE_FADED,
+  AUDIO_CHANNEL_STATE_LAST
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif
+
diff --git a/dom/audiochannel/AudioChannelService.cpp b/dom/audiochannel/AudioChannelService.cpp
index 6ce82c4315e..87eceb2a8ad 100644
--- a/dom/audiochannel/AudioChannelService.cpp
+++ b/dom/audiochannel/AudioChannelService.cpp
@@ -5,6 +5,7 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "AudioChannelService.h"
+#include "AudioChannelServiceChild.h"
 
 #include "base/basictypes.h"
 
@@ -12,11 +13,9 @@
 #include "mozilla/StaticPtr.h"
 #include "mozilla/unused.h"
 
-#include "mozilla/dom/ContentChild.h"
 #include "mozilla/dom/ContentParent.h"
 
 #include "nsContentUtils.h"
-#include "nsIScriptSecurityManager.h"
 #include "nsISupportsPrimitives.h"
 #include "nsThreadUtils.h"
 #include "nsHashPropertyBag.h"
@@ -38,54 +37,18 @@ using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::hal;
 
-namespace {
-
-void
-NotifyChannelActive(uint64_t aWindowID, AudioChannel aAudioChannel,
-                    bool aActive)
+// When a inner-window is destroyed we have to mute all the related
+// AudioChannelAgents. In order to do this we have to notify them after purging
+// AudioChannelService::mAgents.
+struct MOZ_STACK_CLASS WindowDestroyedEnumeratorData
 {
-  nsCOMPtr<nsIObserverService> observerService =
-    services::GetObserverService();
-  if (NS_WARN_IF(!observerService)) {
-    return;
-  }
+  explicit WindowDestroyedEnumeratorData(uint64_t aInnerID)
+    : mInnerID(aInnerID)
+  {}
 
-  nsCOMPtr<nsISupportsPRUint64> wrapper =
-    do_CreateInstance(NS_SUPPORTS_PRUINT64_CONTRACTID);
-  if (!wrapper) {
-     return;
-  }
-
-  wrapper->SetData(aWindowID);
-
-  nsAutoString name;
-  AudioChannelService::GetAudioChannelString(aAudioChannel, name);
-
-  nsAutoCString topic;
-  topic.Assign("audiochannel-activity-");
-  topic.Append(NS_ConvertUTF16toUTF8(name));
-
-  observerService->NotifyObservers(wrapper, topic.get(),
-                                   aActive
-                                     ? MOZ_UTF16("active") : MOZ_UTF16("inactive"));
-}
-
-already_AddRefed<nsPIDOMWindow>
-GetTopWindow(nsIDOMWindow* aWindow)
-{
-  MOZ_ASSERT(aWindow);
-
-  nsCOMPtr<nsIDOMWindow> topWindow;
-  aWindow->GetScriptableTop(getter_AddRefs(topWindow));
-  MOZ_ASSERT(topWindow);
-
-  nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(topWindow);
-  window = window->GetOuterWindow();
-
-  return window.forget();
-}
-
-} // anonymous namespace
+  nsTArray<nsRefPtr<AudioChannelAgent>> mAgents;
+  uint64_t mInnerID;
+};
 
 StaticRefPtr<AudioChannelService> gAudioChannelService;
 
@@ -101,52 +64,63 @@ static const nsAttrValue::EnumTable kMozAudioChannelAttributeTable[] = {
   { nullptr }
 };
 
-/* static */ already_AddRefed<AudioChannelService>
-AudioChannelService::GetOrCreate()
+// static
+AudioChannelService*
+AudioChannelService::GetAudioChannelService()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
-  if (!gAudioChannelService) {
-    gAudioChannelService = new AudioChannelService();
+  if (!XRE_IsParentProcess()) {
+    return AudioChannelServiceChild::GetAudioChannelService();
   }
 
-  nsRefPtr<AudioChannelService> service = gAudioChannelService.get();
-  return service.forget();
+  return gAudioChannelService;
+
+}
+
+// static
+AudioChannelService*
+AudioChannelService::GetOrCreateAudioChannelService()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!XRE_IsParentProcess()) {
+    return AudioChannelServiceChild::GetOrCreateAudioChannelService();
+  }
+
+  // If we already exist, exit early
+  if (gAudioChannelService) {
+    return gAudioChannelService;
+  }
+
+  // Create new instance, register, return
+  nsRefPtr<AudioChannelService> service = new AudioChannelService();
+  MOZ_ASSERT(service);
+
+  gAudioChannelService = service;
+  return gAudioChannelService;
 }
 
 void
 AudioChannelService::Shutdown()
 {
-  if (gAudioChannelService) {
-    if (XRE_GetProcessType() == GeckoProcessType_Default) {
-      nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-      if (obs) {
-        obs->RemoveObserver(gAudioChannelService, "ipc:content-shutdown");
-        obs->RemoveObserver(gAudioChannelService, "xpcom-shutdown");
-        obs->RemoveObserver(gAudioChannelService, "inner-window-destroyed");
-#ifdef MOZ_WIDGET_GONK
-        // To monitor the volume settings based on audio channel.
-        obs->RemoveObserver(gAudioChannelService, "mozsettings-changed");
-#endif
-      }
-    }
+  if (!XRE_IsParentProcess()) {
+    return AudioChannelServiceChild::Shutdown();
+  }
 
+  if (gAudioChannelService) {
     gAudioChannelService = nullptr;
   }
 }
 
-NS_INTERFACE_MAP_BEGIN(AudioChannelService)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAudioChannelService)
-  NS_INTERFACE_MAP_ENTRY(nsIAudioChannelService)
-  NS_INTERFACE_MAP_ENTRY(nsIObserver)
-NS_INTERFACE_MAP_END
-
-NS_IMPL_ADDREF(AudioChannelService)
-NS_IMPL_RELEASE(AudioChannelService)
+NS_IMPL_ISUPPORTS(AudioChannelService, nsIObserver, nsITimerCallback)
 
 AudioChannelService::AudioChannelService()
-  : mDisabled(false)
-  , mDefChannelChildID(CONTENT_PROCESS_ID_UNKNOWN)
+: mCurrentHigherChannel(-1)
+, mCurrentVisibleHigherChannel(-1)
+, mPlayableHiddenContentChildID(CONTENT_PROCESS_ID_UNKNOWN)
+, mDisabled(false)
+, mDefChannelChildID(CONTENT_PROCESS_ID_UNKNOWN)
 {
   if (XRE_IsParentProcess()) {
     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
@@ -168,29 +142,23 @@ AudioChannelService::~AudioChannelService()
 
 void
 AudioChannelService::RegisterAudioChannelAgent(AudioChannelAgent* aAgent,
-                                               AudioChannel aChannel)
+                                               AudioChannel aChannel,
+                                               bool aWithVideo)
 {
   if (mDisabled) {
     return;
   }
 
-  uint64_t windowID = aAgent->WindowID();
-  AudioChannelWindow* winData = mWindows.LookupOrAdd(windowID);
-
-  MOZ_ASSERT(!winData->mAgents.Get(aAgent));
-
-  AudioChannel* audioChannel = new AudioChannel(aChannel);
-  winData->mAgents.Put(aAgent, audioChannel);
-
-  ++winData->mChannels[(uint32_t)aChannel].mNumberOfAgents;
-
-  // The first one, we must inform the BrowserElementAudioChannel.
-  if (winData->mChannels[(uint32_t)aChannel].mNumberOfAgents == 1) {
-    NotifyChannelActive(aAgent->WindowID(), aChannel, true);
-  }
+  AudioChannelAgentData* data = new AudioChannelAgentData(aChannel,
+                                true /* aElementHidden */,
+                                AUDIO_CHANNEL_STATE_MUTED /* aState */,
+                                aWithVideo);
+  mAgents.Put(aAgent, data);
+  RegisterType(aChannel, CONTENT_PROCESS_ID_MAIN, aWithVideo);
 
   // If this is the first agent for this window, we must notify the observers.
-  if (winData->mAgents.Count() == 1) {
+  uint32_t count = CountWindow(aAgent->Window());
+  if (count == 1) {
     nsCOMPtr<nsIObserverService> observerService =
       services::GetObserverService();
     if (observerService) {
@@ -201,6 +169,61 @@ AudioChannelService::RegisterAudioChannelAgent(AudioChannelAgent* aAgent,
   }
 }
 
+void
+AudioChannelService::RegisterType(AudioChannel aChannel, uint64_t aChildID,
+                                  bool aWithVideo)
+{
+  if (mDisabled) {
+    return;
+  }
+
+  AudioChannelInternalType type = GetInternalType(aChannel, true);
+  mChannelCounters[type].AppendElement(aChildID);
+
+  if (XRE_IsParentProcess()) {
+
+    // We must keep the childIds in order to decide which app is allowed to play
+    // with then telephony channel.
+    if (aChannel == AudioChannel::Telephony) {
+      RegisterTelephonyChild(aChildID);
+    }
+
+    // Since there is another telephony registered, we can unregister old one
+    // immediately.
+    if (mDeferTelChannelTimer && aChannel == AudioChannel::Telephony) {
+      mDeferTelChannelTimer->Cancel();
+      mDeferTelChannelTimer = nullptr;
+      UnregisterTypeInternal(aChannel, mTimerElementHidden, mTimerChildID,
+                             false);
+    }
+
+    if (aWithVideo) {
+      mWithVideoChildIDs.AppendElement(aChildID);
+    }
+
+    // No hidden content channel can be playable if there is a content channel
+    // in foreground (bug 855208), nor if there is a normal channel with video
+    // in foreground (bug 894249).
+    if (type == AUDIO_CHANNEL_INT_CONTENT ||
+        (type == AUDIO_CHANNEL_INT_NORMAL &&
+         mWithVideoChildIDs.Contains(aChildID))) {
+      mPlayableHiddenContentChildID = CONTENT_PROCESS_ID_UNKNOWN;
+    }
+    // One hidden content channel can be playable only when there is no any
+    // content channel in the foreground, and no normal channel with video in
+    // foreground.
+    else if (type == AUDIO_CHANNEL_INT_CONTENT_HIDDEN &&
+        mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].IsEmpty()) {
+      mPlayableHiddenContentChildID = aChildID;
+    }
+
+    // In order to avoid race conditions, it's safer to notify any existing
+    // agent any time a new one is registered.
+    SendAudioChannelChangedNotification(aChildID);
+    SendNotification();
+  }
+}
+
 void
 AudioChannelService::UnregisterAudioChannelAgent(AudioChannelAgent* aAgent)
 {
@@ -208,23 +231,12 @@ AudioChannelService::UnregisterAudioChannelAgent(AudioChannelAgent* aAgent)
     return;
   }
 
-  uint64_t windowID = aAgent->WindowID();
-  AudioChannelWindow* winData = nullptr;
-  if (!mWindows.Get(windowID, &winData)) {
-    return;
-  }
+  nsAutoPtr<AudioChannelAgentData> data;
+  mAgents.RemoveAndForget(aAgent, data);
 
-  nsAutoPtr<AudioChannel> audioChannel;
-  winData->mAgents.RemoveAndForget(aAgent, audioChannel);
-  if (audioChannel) {
-    MOZ_ASSERT(winData->mChannels[(uint32_t)*audioChannel].mNumberOfAgents > 0);
-
-    --winData->mChannels[(uint32_t)*audioChannel].mNumberOfAgents;
-
-    // The last one, we must inform the BrowserElementAudioChannel.
-    if (winData->mChannels[(uint32_t)*audioChannel].mNumberOfAgents == 0) {
-      NotifyChannelActive(aAgent->WindowID(), *audioChannel, false);
-    }
+  if (data) {
+    UnregisterType(data->mChannel, data->mElementHidden,
+                   CONTENT_PROCESS_ID_MAIN, data->mWithVideo);
   }
 
 #ifdef MOZ_WIDGET_GONK
@@ -235,7 +247,8 @@ AudioChannelService::UnregisterAudioChannelAgent(AudioChannelAgent* aAgent)
 #endif
 
   // If this is the last agent for this window, we must notify the observers.
-  if (winData->mAgents.Count() == 0) {
+  uint32_t count = CountWindow(aAgent->Window());
+  if (count == 0) {
     nsCOMPtr<nsIObserverService> observerService =
       services::GetObserverService();
     if (observerService) {
@@ -247,118 +260,616 @@ AudioChannelService::UnregisterAudioChannelAgent(AudioChannelAgent* aAgent)
 }
 
 void
-AudioChannelService::GetState(nsPIDOMWindow* aWindow, uint32_t aAudioChannel,
-                              float* aVolume, bool* aMuted)
+AudioChannelService::UnregisterType(AudioChannel aChannel,
+                                    bool aElementHidden,
+                                    uint64_t aChildID,
+                                    bool aWithVideo)
 {
-  MOZ_ASSERT(!aWindow || aWindow->IsOuterWindow());
-  MOZ_ASSERT(aVolume && aMuted);
-  MOZ_ASSERT(aAudioChannel < NUMBER_OF_AUDIO_CHANNELS);
-
-  *aVolume = 1.0;
-  *aMuted = false;
-
-  if (!aWindow || !aWindow->IsOuterWindow()) {
+  if (mDisabled) {
     return;
   }
 
-  AudioChannelWindow* winData = nullptr;
-  nsCOMPtr<nsPIDOMWindow> window = aWindow;
+  // There are two reasons to defer the decrease of telephony channel.
+  // 1. User can have time to remove device from his ear before music resuming.
+  // 2. Give BT SCO to be disconnected before starting to connect A2DP.
+  if (XRE_IsParentProcess()) {
 
-  // The volume must be calculated based on the window hierarchy. Here we go up
-  // to the top window and we calculate the volume and the muted flag.
-  do {
-    if (mWindows.Get(window->WindowID(), &winData)) {
-      *aVolume *= winData->mChannels[aAudioChannel].mVolume;
-      *aMuted = *aMuted || winData->mChannels[aAudioChannel].mMuted;
+    if (aChannel == AudioChannel::Telephony) {
+      UnregisterTelephonyChild(aChildID);
     }
 
-    *aVolume *= window->GetAudioVolume();
-    *aMuted = *aMuted || window->GetAudioMuted();
-
-    nsCOMPtr<nsIDOMWindow> win;
-    window->GetScriptableParent(getter_AddRefs(win));
-    if (window == win) {
-      break;
+    if (aChannel == AudioChannel::Telephony &&
+        (mChannelCounters[AUDIO_CHANNEL_INT_TELEPHONY_HIDDEN].Length() +
+         mChannelCounters[AUDIO_CHANNEL_INT_TELEPHONY].Length()) == 1) {
+      mTimerElementHidden = aElementHidden;
+      mTimerChildID = aChildID;
+      mDeferTelChannelTimer = do_CreateInstance("@mozilla.org/timer;1");
+      mDeferTelChannelTimer->InitWithCallback(this, 1500, nsITimer::TYPE_ONE_SHOT);
+      return;
     }
+  }
 
-    window = do_QueryInterface(win);
-
-    // If there is no parent, or we are the toplevel we don't continue.
-  } while (window && window != aWindow);
+  UnregisterTypeInternal(aChannel, aElementHidden, aChildID, aWithVideo);
 }
 
-PLDHashOperator
-AudioChannelService::TelephonyChannelIsActiveEnumerator(
-                                        const uint64_t& aWindowID,
-                                        nsAutoPtr<AudioChannelWindow>& aWinData,
-                                        void* aPtr)
+void
+AudioChannelService::UnregisterTypeInternal(AudioChannel aChannel,
+                                            bool aElementHidden,
+                                            uint64_t aChildID,
+                                            bool aWithVideo)
 {
-  bool* isActive = static_cast<bool*>(aPtr);
-  *isActive =
-    aWinData->mChannels[(uint32_t)AudioChannel::Telephony].mNumberOfAgents != 0 &&
-   !aWinData->mChannels[(uint32_t)AudioChannel::Telephony].mMuted;
-  return *isActive ? PL_DHASH_STOP : PL_DHASH_NEXT;
+  // The array may contain multiple occurrence of this appId but
+  // this should remove only the first one.
+  AudioChannelInternalType type = GetInternalType(aChannel, aElementHidden);
+  MOZ_ASSERT(mChannelCounters[type].Contains(aChildID));
+  mChannelCounters[type].RemoveElement(aChildID);
+
+  // In order to avoid race conditions, it's safer to notify any existing
+  // agent any time a new one is registered.
+  if (XRE_IsParentProcess()) {
+    // No hidden content channel is playable if the original playable hidden
+    // process does not need to play audio from background anymore.
+    if (aChannel == AudioChannel::Content &&
+        mPlayableHiddenContentChildID == aChildID &&
+        !mChannelCounters[AUDIO_CHANNEL_INT_CONTENT_HIDDEN].Contains(aChildID)) {
+      mPlayableHiddenContentChildID = CONTENT_PROCESS_ID_UNKNOWN;
+    }
+
+    if (aWithVideo) {
+      MOZ_ASSERT(mWithVideoChildIDs.Contains(aChildID));
+      mWithVideoChildIDs.RemoveElement(aChildID);
+    }
+
+    SendAudioChannelChangedNotification(aChildID);
+    SendNotification();
+  }
+}
+
+void
+AudioChannelService::UpdateChannelType(AudioChannel aChannel,
+                                       uint64_t aChildID,
+                                       bool aElementHidden,
+                                       bool aElementWasHidden)
+{
+  // Calculate the new and old internal type and update the hashtable if needed.
+  AudioChannelInternalType newType = GetInternalType(aChannel, aElementHidden);
+  AudioChannelInternalType oldType = GetInternalType(aChannel, aElementWasHidden);
+
+  if (newType != oldType) {
+    mChannelCounters[newType].AppendElement(aChildID);
+    MOZ_ASSERT(mChannelCounters[oldType].Contains(aChildID));
+    mChannelCounters[oldType].RemoveElement(aChildID);
+  }
+
+  // No hidden content channel can be playable if there is a content channel
+  // in foreground (bug 855208), nor if there is a normal channel with video
+  // in foreground (bug 894249).
+  if (newType == AUDIO_CHANNEL_INT_CONTENT ||
+      (newType == AUDIO_CHANNEL_INT_NORMAL &&
+       mWithVideoChildIDs.Contains(aChildID))) {
+    mPlayableHiddenContentChildID = CONTENT_PROCESS_ID_UNKNOWN;
+  }
+  // If there is no content channel in foreground and no normal channel with
+  // video in foreground, the last content channel which goes from foreground
+  // to background can be playable.
+  else if (oldType == AUDIO_CHANNEL_INT_CONTENT &&
+      newType == AUDIO_CHANNEL_INT_CONTENT_HIDDEN &&
+      mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].IsEmpty()) {
+    mPlayableHiddenContentChildID = aChildID;
+  }
+}
+
+AudioChannelState
+AudioChannelService::GetState(AudioChannelAgent* aAgent, bool aElementHidden)
+{
+  AudioChannelAgentData* data;
+  if (!mAgents.Get(aAgent, &data)) {
+    return AUDIO_CHANNEL_STATE_MUTED;
+  }
+
+  bool oldElementHidden = data->mElementHidden;
+  // Update visibility.
+  data->mElementHidden = aElementHidden;
+
+  data->mState = GetStateInternal(data->mChannel, CONTENT_PROCESS_ID_MAIN,
+                                aElementHidden, oldElementHidden);
+  #ifdef MOZ_WIDGET_GONK
+  /** Only modify the speaker status when
+   *  (1) apps in the foreground.
+   *  (2) apps in the backgrund and inactive.
+   *  Notice : check the state when the visible status is stable, because there
+   *  has lantency in passing the visibility events.
+   **/
+  bool active = AnyAudioChannelIsActive();
+  if (aElementHidden == oldElementHidden &&
+      (!aElementHidden || (aElementHidden && !active))) {
+    for (uint32_t i = 0; i < mSpeakerManager.Length(); i++) {
+      mSpeakerManager[i]->SetAudioChannelActive(active);
+    }
+  }
+  #endif
+
+  return data->mState;
+}
+
+AudioChannelState
+AudioChannelService::GetStateInternal(AudioChannel aChannel, uint64_t aChildID,
+                                      bool aElementHidden,
+                                      bool aElementWasHidden)
+{
+  UpdateChannelType(aChannel, aChildID, aElementHidden, aElementWasHidden);
+
+  // Calculating the new and old type and update the hashtable if needed.
+  AudioChannelInternalType newType = GetInternalType(aChannel, aElementHidden);
+  AudioChannelInternalType oldType = GetInternalType(aChannel,
+                                                     aElementWasHidden);
+
+  if (newType != oldType &&
+      (aChannel == AudioChannel::Content ||
+       (aChannel == AudioChannel::Normal &&
+        mWithVideoChildIDs.Contains(aChildID)))) {
+    SendNotification();
+  }
+
+  SendAudioChannelChangedNotification(aChildID);
+
+  // Let play any visible audio channel.
+  if (!aElementHidden) {
+    if (CheckVolumeFadedCondition(newType, aElementHidden)) {
+      return AUDIO_CHANNEL_STATE_FADED;
+    }
+    return CheckTelephonyPolicy(aChannel, aChildID);
+  }
+
+  // We are not visible, maybe we have to mute.
+  if (newType == AUDIO_CHANNEL_INT_NORMAL_HIDDEN ||
+      (newType == AUDIO_CHANNEL_INT_CONTENT_HIDDEN &&
+       // One process can have multiple content channels; and during the
+       // transition from foreground to background, its content channels will be
+       // updated with correct visibility status one by one. All its content
+       // channels should remain playable until all of their visibility statuses
+       // have been updated as hidden. After all its content channels have been
+       // updated properly as hidden, mPlayableHiddenContentChildID is used to
+       // check whether this background process is playable or not.
+       !(mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].Contains(aChildID) ||
+         (mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].IsEmpty() &&
+          mPlayableHiddenContentChildID == aChildID)))) {
+    return AUDIO_CHANNEL_STATE_MUTED;
+  }
+
+  // After checking the condition on normal & content channel, if the state
+  // is not on muted then checking other higher channels type here.
+  if (ChannelsActiveWithHigherPriorityThan(newType)) {
+    MOZ_ASSERT(newType != AUDIO_CHANNEL_INT_NORMAL_HIDDEN);
+    if (CheckVolumeFadedCondition(newType, aElementHidden)) {
+      return AUDIO_CHANNEL_STATE_FADED;
+    }
+    return AUDIO_CHANNEL_STATE_MUTED;
+  }
+
+  return CheckTelephonyPolicy(aChannel, aChildID);
+}
+
+AudioChannelState
+AudioChannelService::CheckTelephonyPolicy(AudioChannel aChannel,
+                                          uint64_t aChildID)
+{
+  // Only the latest childID is allowed to play with telephony channel.
+  if (aChannel != AudioChannel::Telephony) {
+    return AUDIO_CHANNEL_STATE_NORMAL;
+  }
+
+  MOZ_ASSERT(!mTelephonyChildren.IsEmpty());
+
+#if DEBUG
+  bool found = false;
+  for (uint32_t i = 0, len = mTelephonyChildren.Length(); i < len; ++i) {
+    if (mTelephonyChildren[i].mChildID == aChildID) {
+      found = true;
+      break;
+    }
+  }
+
+  MOZ_ASSERT(found);
+#endif
+
+  return mTelephonyChildren.LastElement().mChildID == aChildID
+           ? AUDIO_CHANNEL_STATE_NORMAL : AUDIO_CHANNEL_STATE_MUTED;
+}
+
+bool
+AudioChannelService::CheckVolumeFadedCondition(AudioChannelInternalType aType,
+                                               bool aElementHidden)
+{
+  // Only normal & content channels are considered
+  if (aType > AUDIO_CHANNEL_INT_CONTENT_HIDDEN) {
+    return false;
+  }
+
+  // Consider that audio from notification is with short duration
+  // so just fade the volume not pause it
+  if (mChannelCounters[AUDIO_CHANNEL_INT_NOTIFICATION].IsEmpty() &&
+      mChannelCounters[AUDIO_CHANNEL_INT_NOTIFICATION_HIDDEN].IsEmpty()) {
+    return false;
+  }
+
+  // Since this element is on the foreground, it can be allowed to play always.
+  // So return true directly when there is any notification channel alive.
+  if (aElementHidden == false) {
+   return true;
+  }
+
+  // If element is on the background, it is possible paused by channels higher
+  // then notification.
+  for (int i = AUDIO_CHANNEL_INT_LAST - 1;
+    i != AUDIO_CHANNEL_INT_NOTIFICATION_HIDDEN; --i) {
+    if (!mChannelCounters[i].IsEmpty()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool
+AudioChannelService::ContentOrNormalChannelIsActive()
+{
+  return !mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].IsEmpty() ||
+         !mChannelCounters[AUDIO_CHANNEL_INT_CONTENT_HIDDEN].IsEmpty() ||
+         !mChannelCounters[AUDIO_CHANNEL_INT_NORMAL].IsEmpty();
 }
 
 bool
 AudioChannelService::TelephonyChannelIsActive()
 {
-  // TODO: no child process check.
-
-  bool active = false;
-  mWindows.Enumerate(TelephonyChannelIsActiveEnumerator, &active);
-  return active;
+  return !mChannelCounters[AUDIO_CHANNEL_INT_TELEPHONY].IsEmpty() ||
+         !mChannelCounters[AUDIO_CHANNEL_INT_TELEPHONY_HIDDEN].IsEmpty();
 }
 
 bool
 AudioChannelService::ProcessContentOrNormalChannelIsActive(uint64_t aChildID)
 {
-/* TODO
-  AudioChannelChildData* data;
-  if (!mData.Get(aChildID, &data)) {
-    return false;
-  }
-
-  return data->mChannels[(uint32_t)AudioChannel::Content].mNumberOfAgents != 0 ||
-         data->mChannels[(uint32_t)AudioChannel::Normal].mNumberOfAgents != 0;
-*/
-  return true;
+  return mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].Contains(aChildID) ||
+         mChannelCounters[AUDIO_CHANNEL_INT_CONTENT_HIDDEN].Contains(aChildID) ||
+         mChannelCounters[AUDIO_CHANNEL_INT_NORMAL].Contains(aChildID);
 }
 
-PLDHashOperator
-AudioChannelService::AnyAudioChannelIsActiveEnumerator(
-                                        const uint64_t& aWindowID,
-                                        nsAutoPtr<AudioChannelWindow>& aWinData,
-                                        void* aPtr)
+void
+AudioChannelService::SetDefaultVolumeControlChannel(int32_t aChannel,
+                                                    bool aVisible)
 {
-  bool* isActive = static_cast<bool*>(aPtr);
-  for (uint32_t i = 0; kMozAudioChannelAttributeTable[i].tag; ++i) {
-    if (aWinData->mChannels[kMozAudioChannelAttributeTable[i].value].mNumberOfAgents
-        != 0) {
-      *isActive = true;
+  SetDefaultVolumeControlChannelInternal(aChannel, aVisible,
+                                         CONTENT_PROCESS_ID_MAIN);
+}
+
+void
+AudioChannelService::SetDefaultVolumeControlChannelInternal(int32_t aChannel,
+                                                            bool aVisible,
+                                                            uint64_t aChildID)
+{
+  if (!XRE_IsParentProcess()) {
+    return;
+  }
+
+  // If this child is in the background and mDefChannelChildID is set to
+  // others then it means other child in the foreground already set it's
+  // own default channel already.
+  if (!aVisible && mDefChannelChildID != aChildID) {
+    return;
+  }
+  // Workaround for the call screen app. The call screen app is running on the
+  // main process, that will results in wrong visible state. Because we use the
+  // docshell's active state as visible state, the main process is always
+  // active. Therefore, we will see the strange situation that the visible
+  // state of the call screen is always true. If the mDefChannelChildID is set
+  // to others then it means other child in the foreground already set it's
+  // own default channel already.
+  // Summary :
+  //   Child process : foreground app always can set type.
+  //   Parent process : check the mDefChannelChildID.
+  else if (aChildID == CONTENT_PROCESS_ID_MAIN &&
+           mDefChannelChildID != CONTENT_PROCESS_ID_UNKNOWN) {
+    return;
+  }
+
+  mDefChannelChildID = aVisible ? aChildID : CONTENT_PROCESS_ID_UNKNOWN;
+  nsAutoString channelName;
+  if (aChannel == -1) {
+    channelName.AssignASCII("unknown");
+  } else {
+    GetAudioChannelString(static_cast<AudioChannel>(aChannel), channelName);
+  }
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "default-volume-channel-changed",
+                         channelName.get());
+  }
+}
+
+void
+AudioChannelService::SendAudioChannelChangedNotification(uint64_t aChildID)
+{
+  if (!XRE_IsParentProcess()) {
+    return;
+  }
+
+  nsRefPtr<nsHashPropertyBag> props = new nsHashPropertyBag();
+  props->SetPropertyAsUint64(NS_LITERAL_STRING("childID"), aChildID);
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(static_cast<nsIWritablePropertyBag*>(props),
+                         "audio-channel-process-changed", nullptr);
+  }
+
+  // Calculating the most important active channel.
+  int32_t higher = -1;
+
+  // Top-Down in the hierarchy for visible elements
+  if (!mChannelCounters[AUDIO_CHANNEL_INT_PUBLICNOTIFICATION].IsEmpty()) {
+    higher = static_cast<int32_t>(AudioChannel::Publicnotification);
+  }
+
+  else if (!mChannelCounters[AUDIO_CHANNEL_INT_RINGER].IsEmpty()) {
+    higher = static_cast<int32_t>(AudioChannel::Ringer);
+  }
+
+  else if (!mChannelCounters[AUDIO_CHANNEL_INT_TELEPHONY].IsEmpty()) {
+    higher = static_cast<int32_t>(AudioChannel::Telephony);
+  }
+
+  else if (!mChannelCounters[AUDIO_CHANNEL_INT_ALARM].IsEmpty()) {
+    higher = static_cast<int32_t>(AudioChannel::Alarm);
+  }
+
+  else if (!mChannelCounters[AUDIO_CHANNEL_INT_NOTIFICATION].IsEmpty()) {
+    higher = static_cast<int32_t>(AudioChannel::Notification);
+  }
+
+  else if (!mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].IsEmpty()) {
+    higher = static_cast<int32_t>(AudioChannel::Content);
+  }
+
+  else if (!mChannelCounters[AUDIO_CHANNEL_INT_NORMAL].IsEmpty()) {
+    higher = static_cast<int32_t>(AudioChannel::Normal);
+  }
+
+  int32_t visibleHigher = higher;
+
+  // Top-Down in the hierarchy for non-visible elements
+  // And we can ignore normal channel because it can't play in the background.
+  int32_t index;
+  for (index = 0; kMozAudioChannelAttributeTable[index].tag; ++index);
+
+  for (--index;
+       kMozAudioChannelAttributeTable[index].value > higher &&
+       kMozAudioChannelAttributeTable[index].value > (int16_t)AudioChannel::Normal;
+       --index) {
+    // Each channel type will be split to fg and bg for recording the state,
+    // so here need to do a translation.
+    if (mChannelCounters[index * 2 + 1].IsEmpty()) {
+      continue;
+    }
+
+    if (kMozAudioChannelAttributeTable[index].value == (int16_t)AudioChannel::Content) {
+      if (mPlayableHiddenContentChildID != CONTENT_PROCESS_ID_UNKNOWN) {
+        higher = kMozAudioChannelAttributeTable[index].value;
+        break;
+      }
+    } else {
+      higher = kMozAudioChannelAttributeTable[index].value;
       break;
     }
   }
 
-  return *isActive ? PL_DHASH_STOP : PL_DHASH_NEXT;
+  if (higher != mCurrentHigherChannel) {
+    mCurrentHigherChannel = higher;
+
+    nsString channelName;
+    if (mCurrentHigherChannel != -1) {
+      GetAudioChannelString(static_cast<AudioChannel>(mCurrentHigherChannel),
+                            channelName);
+    } else {
+      channelName.AssignLiteral("none");
+    }
+
+    if (obs) {
+      obs->NotifyObservers(nullptr, "audio-channel-changed", channelName.get());
+    }
+  }
+
+  if (visibleHigher != mCurrentVisibleHigherChannel) {
+    mCurrentVisibleHigherChannel = visibleHigher;
+
+    nsString channelName;
+    if (mCurrentVisibleHigherChannel != -1) {
+      GetAudioChannelString(static_cast<AudioChannel>(mCurrentVisibleHigherChannel),
+                            channelName);
+    } else {
+      channelName.AssignLiteral("none");
+    }
+
+    if (obs) {
+      obs->NotifyObservers(nullptr, "visible-audio-channel-changed", channelName.get());
+    }
+  }
+}
+
+PLDHashOperator
+AudioChannelService::NotifyEnumerator(AudioChannelAgent* aAgent,
+                                      AudioChannelAgentData* aData, void* aUnused)
+{
+  MOZ_ASSERT(aAgent);
+  aAgent->NotifyAudioChannelStateChanged();
+  return PL_DHASH_NEXT;
+}
+
+class NotifyRunnable : public nsRunnable
+{
+public:
+  explicit NotifyRunnable(AudioChannelService* aService)
+    : mService(aService)
+  {}
+
+  NS_IMETHOD Run()
+  {
+    mService->Notify();
+    return NS_OK;
+  }
+
+private:
+  nsRefPtr<AudioChannelService> mService;
+};
+
+void
+AudioChannelService::SendNotification()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mRunnable) {
+    return;
+  }
+
+  mRunnable = new NotifyRunnable(this);
+  NS_DispatchToCurrentThread(mRunnable);
+}
+
+void
+AudioChannelService::Notify()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  mRunnable = nullptr;
+
+  // Notify any agent for the main process.
+  mAgents.EnumerateRead(NotifyEnumerator, nullptr);
+
+  // Notify for the child processes.
+  nsTArray<ContentParent*> children;
+  ContentParent::GetAll(children);
+  for (uint32_t i = 0; i < children.Length(); i++) {
+    unused << children[i]->SendAudioChannelNotify();
+  }
+}
+
+NS_IMETHODIMP
+AudioChannelService::Notify(nsITimer* aTimer)
+{
+  UnregisterTypeInternal(AudioChannel::Telephony, mTimerElementHidden,
+                         mTimerChildID, false);
+  mDeferTelChannelTimer = nullptr;
+  return NS_OK;
 }
 
 bool
 AudioChannelService::AnyAudioChannelIsActive()
 {
-  // TODO: no child process check.
-  bool active = false;
-  mWindows.Enumerate(AnyAudioChannelIsActiveEnumerator, &active);
-  return active;
+  for (int i = AUDIO_CHANNEL_INT_LAST - 1;
+       i >= AUDIO_CHANNEL_INT_NORMAL; --i) {
+    if (!mChannelCounters[i].IsEmpty()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool
+AudioChannelService::ChannelsActiveWithHigherPriorityThan(
+  AudioChannelInternalType aType)
+{
+  for (int i = AUDIO_CHANNEL_INT_LAST - 1;
+       i != AUDIO_CHANNEL_INT_CONTENT_HIDDEN; --i) {
+    if (i == aType) {
+      return false;
+    }
+
+    if (!mChannelCounters[i].IsEmpty()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+PLDHashOperator
+AudioChannelService::WindowDestroyedEnumerator(AudioChannelAgent* aAgent,
+                                               nsAutoPtr<AudioChannelAgentData>& aData,
+                                               void* aPtr)
+{
+  auto* data = static_cast<WindowDestroyedEnumeratorData*>(aPtr);
+  MOZ_ASSERT(data);
+
+  nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aAgent->Window());
+  if (window && !window->IsInnerWindow()) {
+    window = window->GetCurrentInnerWindow();
+  }
+
+  if (!window || window->WindowID() != data->mInnerID) {
+    return PL_DHASH_NEXT;
+  }
+
+  AudioChannelService* service = AudioChannelService::GetAudioChannelService();
+  MOZ_ASSERT(service);
+
+  service->UnregisterType(aData->mChannel, aData->mElementHidden,
+                          CONTENT_PROCESS_ID_MAIN, aData->mWithVideo);
+  data->mAgents.AppendElement(aAgent);
+
+  return PL_DHASH_REMOVE;
 }
 
 NS_IMETHODIMP
-AudioChannelService::Observe(nsISupports* aSubject, const char* aTopic,
-                             const char16_t* aData)
+AudioChannelService::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
 {
   if (!strcmp(aTopic, "xpcom-shutdown")) {
     mDisabled = true;
-    mWindows.Clear();
+  }
+
+  if (!strcmp(aTopic, "ipc:content-shutdown")) {
+    nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
+    if (!props) {
+      NS_WARNING("ipc:content-shutdown message without property bag as subject");
+      return NS_OK;
+    }
+
+    int32_t index;
+    uint64_t childID = 0;
+    nsresult rv = props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"),
+                                             &childID);
+    if (NS_SUCCEEDED(rv)) {
+      for (int32_t type = AUDIO_CHANNEL_INT_NORMAL;
+           type < AUDIO_CHANNEL_INT_LAST;
+           ++type) {
+
+        while ((index = mChannelCounters[type].IndexOf(childID)) != -1) {
+          mChannelCounters[type].RemoveElementAt(index);
+        }
+      }
+
+      // No hidden content channel is playable if the original playable hidden
+      // process shuts down.
+      if (mPlayableHiddenContentChildID == childID) {
+        mPlayableHiddenContentChildID = CONTENT_PROCESS_ID_UNKNOWN;
+      }
+
+      while ((index = mWithVideoChildIDs.IndexOf(childID)) != -1) {
+        mWithVideoChildIDs.RemoveElementAt(index);
+      }
+
+      // We don't have to remove the agents from the mAgents hashtable because if
+      // that table contains only agents running on the same process.
+
+      SendAudioChannelChangedNotification(childID);
+      SendNotification();
+
+      if (mDefChannelChildID == childID) {
+        SetDefaultVolumeControlChannelInternal(-1, false, childID);
+        mDefChannelChildID = CONTENT_PROCESS_ID_UNKNOWN;
+      }
+    } else {
+      NS_WARNING("ipc:content-shutdown message without childID property");
+    }
   }
 
 #ifdef MOZ_WIDGET_GONK
@@ -409,10 +920,10 @@ AudioChannelService::Observe(nsISupports* aSubject, const char* aTopic,
       return rv;
     }
 
-    nsAutoPtr<AudioChannelWindow> window;
-    mWindows.RemoveAndForget(innerID, window);
-    if (window) {
-      window->mAgents.EnumerateRead(NotifyEnumerator, nullptr);
+    WindowDestroyedEnumeratorData data(innerID);
+    mAgents.Enumerate(WindowDestroyedEnumerator, &data);
+    for (uint32_t i = 0, len = data.mAgents.Length(); i < len; ++i) {
+      data.mAgents[i]->NotifyAudioChannelStateChanged();
     }
 
 #ifdef MOZ_WIDGET_GONK
@@ -423,27 +934,54 @@ AudioChannelService::Observe(nsISupports* aSubject, const char* aTopic,
 #endif
   }
 
-  else if (!strcmp(aTopic, "ipc:content-shutdown")) {
-    nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
-    if (!props) {
-      NS_WARNING("ipc:content-shutdown message without property bag as subject");
-      return NS_OK;
-    }
+  return NS_OK;
+}
 
-    uint64_t childID = 0;
-    nsresult rv = props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"),
-                                             &childID);
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return rv;
-    }
+AudioChannelService::AudioChannelInternalType
+AudioChannelService::GetInternalType(AudioChannel aChannel,
+                                     bool aElementHidden)
+{
+  switch (aChannel) {
+    case AudioChannel::Normal:
+      return aElementHidden
+               ? AUDIO_CHANNEL_INT_NORMAL_HIDDEN
+               : AUDIO_CHANNEL_INT_NORMAL;
 
-    if (mDefChannelChildID == childID) {
-      SetDefaultVolumeControlChannelInternal(-1, false, childID);
-      mDefChannelChildID = CONTENT_PROCESS_ID_UNKNOWN;
-    }
+    case AudioChannel::Content:
+      return aElementHidden
+               ? AUDIO_CHANNEL_INT_CONTENT_HIDDEN
+               : AUDIO_CHANNEL_INT_CONTENT;
+
+    case AudioChannel::Notification:
+      return aElementHidden
+               ? AUDIO_CHANNEL_INT_NOTIFICATION_HIDDEN
+               : AUDIO_CHANNEL_INT_NOTIFICATION;
+
+    case AudioChannel::Alarm:
+      return aElementHidden
+               ? AUDIO_CHANNEL_INT_ALARM_HIDDEN
+               : AUDIO_CHANNEL_INT_ALARM;
+
+    case AudioChannel::Telephony:
+      return aElementHidden
+               ? AUDIO_CHANNEL_INT_TELEPHONY_HIDDEN
+               : AUDIO_CHANNEL_INT_TELEPHONY;
+
+    case AudioChannel::Ringer:
+      return aElementHidden
+               ? AUDIO_CHANNEL_INT_RINGER_HIDDEN
+               : AUDIO_CHANNEL_INT_RINGER;
+
+    case AudioChannel::Publicnotification:
+      return aElementHidden
+               ? AUDIO_CHANNEL_INT_PUBLICNOTIFICATION_HIDDEN
+               : AUDIO_CHANNEL_INT_PUBLICNOTIFICATION;
+
+    default:
+      break;
   }
 
-  return NS_OK;
+  MOZ_CRASH("unexpected audio channel");
 }
 
 struct RefreshAgentsVolumeData
@@ -457,24 +995,68 @@ struct RefreshAgentsVolumeData
 };
 
 PLDHashOperator
-AudioChannelService::RefreshAgentsVolumeEnumerator(
-                                                 AudioChannelAgent* aAgent,
-                                                 AudioChannel* aUnused,
-                                                 void* aPtr)
+AudioChannelService::RefreshAgentsVolumeEnumerator(AudioChannelAgent* aAgent,
+                                                   AudioChannelAgentData* aUnused,
+                                                   void* aPtr)
 {
   MOZ_ASSERT(aAgent);
-  aAgent->WindowVolumeChanged();
+  RefreshAgentsVolumeData* data = static_cast<RefreshAgentsVolumeData*>(aPtr);
+  MOZ_ASSERT(data);
+
+  nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aAgent->Window());
+  if (window && !window->IsInnerWindow()) {
+    window = window->GetCurrentInnerWindow();
+  }
+
+  if (window == data->mWindow) {
+    data->mAgents.AppendElement(aAgent);
+  }
+
   return PL_DHASH_NEXT;
 }
 void
 AudioChannelService::RefreshAgentsVolume(nsPIDOMWindow* aWindow)
 {
-  AudioChannelWindow* winData = mWindows.Get(aWindow->WindowID());
-  if (!winData) {
-    return;
+  RefreshAgentsVolumeData data(aWindow);
+  mAgents.EnumerateRead(RefreshAgentsVolumeEnumerator, &data);
+
+  for (uint32_t i = 0; i < data.mAgents.Length(); ++i) {
+    data.mAgents[i]->WindowVolumeChanged();
+  }
+}
+
+struct CountWindowData
+{
+  explicit CountWindowData(nsIDOMWindow* aWindow)
+    : mWindow(aWindow)
+    , mCount(0)
+  {}
+
+  nsIDOMWindow* mWindow;
+  uint32_t mCount;
+};
+
+PLDHashOperator
+AudioChannelService::CountWindowEnumerator(AudioChannelAgent* aAgent,
+                                           AudioChannelAgentData* aUnused,
+                                           void* aPtr)
+{
+  CountWindowData* data = static_cast<CountWindowData*>(aPtr);
+  MOZ_ASSERT(aAgent);
+
+  if (aAgent->Window() == data->mWindow) {
+    ++data->mCount;
   }
 
-  winData->mAgents.EnumerateRead(RefreshAgentsVolumeEnumerator, nullptr);
+  return PL_DHASH_NEXT;
+}
+
+uint32_t
+AudioChannelService::CountWindow(nsIDOMWindow* aWindow)
+{
+  CountWindowData data(aWindow);
+  mAgents.EnumerateRead(CountWindowEnumerator, &data);
+  return data.mCount;
 }
 
 /* static */ const nsAttrValue::EnumTable*
@@ -498,7 +1080,7 @@ AudioChannelService::GetAudioChannel(const nsAString& aChannel)
 /* static */ AudioChannel
 AudioChannelService::GetDefaultAudioChannel()
 {
-  nsAutoString audioChannel(Preferences::GetString("media.defaultAudioChannel"));
+  nsString audioChannel = Preferences::GetString("media.defaultAudioChannel");
   if (audioChannel.IsEmpty()) {
     return AudioChannel::Normal;
   }
@@ -532,7 +1114,7 @@ AudioChannelService::GetDefaultAudioChannelString(nsAString& aString)
 {
   aString.AssignASCII("normal");
 
-  nsAutoString audioChannel(Preferences::GetString("media.defaultAudioChannel"));
+  nsString audioChannel = Preferences::GetString("media.defaultAudioChannel");
   if (!audioChannel.IsEmpty()) {
     for (uint32_t i = 0; kMozAudioChannelAttributeTable[i].tag; ++i) {
       if (audioChannel.EqualsASCII(kMozAudioChannelAttributeTable[i].tag)) {
@@ -543,196 +1125,38 @@ AudioChannelService::GetDefaultAudioChannelString(nsAString& aString)
   }
 }
 
-AudioChannelService::AudioChannelWindow&
-AudioChannelService::GetOrCreateWindowData(nsPIDOMWindow* aWindow)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(aWindow);
-  MOZ_ASSERT(aWindow->IsOuterWindow());
-
-  AudioChannelWindow* winData = mWindows.LookupOrAdd(aWindow->WindowID());
-  return *winData;
-}
-
-float
-AudioChannelService::GetAudioChannelVolume(nsPIDOMWindow* aWindow,
-                                           AudioChannel aAudioChannel)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(aWindow);
-  MOZ_ASSERT(aWindow->IsOuterWindow());
-
-  AudioChannelWindow& winData = GetOrCreateWindowData(aWindow);
-  return winData.mChannels[(uint32_t)aAudioChannel].mVolume;
-}
-
-NS_IMETHODIMP
-AudioChannelService::GetAudioChannelVolume(nsIDOMWindow* aWindow,
-                                           unsigned short aAudioChannel,
-                                           float* aVolume)
-{
-  nsCOMPtr<nsPIDOMWindow> window = GetTopWindow(aWindow);
-  *aVolume = GetAudioChannelVolume(window, (AudioChannel)aAudioChannel);
-  return NS_OK;
-}
-
 void
-AudioChannelService::SetAudioChannelVolume(nsPIDOMWindow* aWindow,
-                                           AudioChannel aAudioChannel,
-                                           float aVolume)
+AudioChannelService::RegisterTelephonyChild(uint64_t aChildID)
 {
-  MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(aWindow);
-  MOZ_ASSERT(aWindow->IsOuterWindow());
+  for (uint32_t i = 0, len = mTelephonyChildren.Length(); i < len; ++i) {
+    if (mTelephonyChildren[i].mChildID == aChildID) {
+      ++mTelephonyChildren[i].mInstances;
 
-  AudioChannelWindow& winData = GetOrCreateWindowData(aWindow);
-  winData.mChannels[(uint32_t)aAudioChannel].mVolume = aVolume;
-  RefreshAgentsVolume(aWindow);
-}
+      if (i != len - 1) {
+        TelephonyChild child = mTelephonyChildren[i];
+        mTelephonyChildren.RemoveElementAt(i);
+        mTelephonyChildren.AppendElement(child);
+      }
 
-NS_IMETHODIMP
-AudioChannelService::SetAudioChannelVolume(nsIDOMWindow* aWindow,
-                                           unsigned short aAudioChannel,
-                                           float aVolume)
-{
-  nsCOMPtr<nsPIDOMWindow> window = GetTopWindow(aWindow);
-  SetAudioChannelVolume(window, (AudioChannel)aAudioChannel, aVolume);
-  return NS_OK;
-}
-
-bool
-AudioChannelService::GetAudioChannelMuted(nsPIDOMWindow* aWindow,
-                                          AudioChannel aAudioChannel)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(aWindow);
-  MOZ_ASSERT(aWindow->IsOuterWindow());
-
-  AudioChannelWindow& winData = GetOrCreateWindowData(aWindow);
-  return winData.mChannels[(uint32_t)aAudioChannel].mMuted;
-}
-
-NS_IMETHODIMP
-AudioChannelService::GetAudioChannelMuted(nsIDOMWindow* aWindow,
-                                          unsigned short aAudioChannel,
-                                          bool* aMuted)
-{
-  nsCOMPtr<nsPIDOMWindow> window = GetTopWindow(aWindow);
-  *aMuted = GetAudioChannelMuted(window, (AudioChannel)aAudioChannel);
-  return NS_OK;
-}
-
-void
-AudioChannelService::SetAudioChannelMuted(nsPIDOMWindow* aWindow,
-                                          AudioChannel aAudioChannel,
-                                          bool aMuted)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(aWindow);
-  MOZ_ASSERT(aWindow->IsOuterWindow());
-
-  AudioChannelWindow& winData = GetOrCreateWindowData(aWindow);
-  winData.mChannels[(uint32_t)aAudioChannel].mMuted = aMuted;
-  RefreshAgentsVolume(aWindow);
-}
-
-NS_IMETHODIMP
-AudioChannelService::SetAudioChannelMuted(nsIDOMWindow* aWindow,
-                                          unsigned short aAudioChannel,
-                                          bool aMuted)
-{
-  nsCOMPtr<nsPIDOMWindow> window = GetTopWindow(aWindow);
-  SetAudioChannelMuted(window, (AudioChannel)aAudioChannel, aMuted);
-  return NS_OK;
-}
-
-bool
-AudioChannelService::IsAudioChannelActive(nsPIDOMWindow* aWindow,
-                                          AudioChannel aAudioChannel)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(aWindow);
-  MOZ_ASSERT(aWindow->IsOuterWindow());
-
-  AudioChannelWindow& winData = GetOrCreateWindowData(aWindow);
-  return !!winData.mChannels[(uint32_t)aAudioChannel].mNumberOfAgents;
-}
-
-NS_IMETHODIMP
-AudioChannelService::IsAudioChannelActive(nsIDOMWindow* aWindow,
-                                          unsigned short aAudioChannel,
-                                          bool* aActive)
-{
-  nsCOMPtr<nsPIDOMWindow> window = GetTopWindow(aWindow);
-  *aActive = IsAudioChannelActive(window, (AudioChannel)aAudioChannel);
-  return NS_OK;
-}
-void
-AudioChannelService::SetDefaultVolumeControlChannel(int32_t aChannel,
-                                                    bool aVisible)
-{
-  SetDefaultVolumeControlChannelInternal(aChannel, aVisible,
-                                         CONTENT_PROCESS_ID_MAIN);
-}
-
-void
-AudioChannelService::SetDefaultVolumeControlChannelInternal(int32_t aChannel,
-                                                            bool aVisible,
-                                                            uint64_t aChildID)
-{
-  if (XRE_GetProcessType() != GeckoProcessType_Default) {
-    ContentChild* cc = ContentChild::GetSingleton();
-    if (cc) {
-      cc->SendAudioChannelChangeDefVolChannel(aChannel, aVisible);
+      return;
     }
-
-    return;
   }
 
-  // If this child is in the background and mDefChannelChildID is set to
-  // others then it means other child in the foreground already set it's
-  // own default channel.
-  if (!aVisible && mDefChannelChildID != aChildID) {
-    return;
-  }
-
-  // Workaround for the call screen app. The call screen app is running on the
-  // main process, that will results in wrong visible state. Because we use the
-  // docshell's active state as visible state, the main process is always
-  // active. Therefore, we will see the strange situation that the visible
-  // state of the call screen is always true. If the mDefChannelChildID is set
-  // to others then it means other child in the foreground already set it's
-  // own default channel already.
-  // Summary :
-  //   Child process : foreground app always can set type.
-  //   Parent process : check the mDefChannelChildID.
-  else if (aChildID == CONTENT_PROCESS_ID_MAIN &&
-           mDefChannelChildID != CONTENT_PROCESS_ID_UNKNOWN) {
-    return;
-  }
-
-  mDefChannelChildID = aVisible ? aChildID : CONTENT_PROCESS_ID_UNKNOWN;
-  nsAutoString channelName;
-
-  if (aChannel == -1) {
-    channelName.AssignASCII("unknown");
-  } else {
-    GetAudioChannelString(static_cast<AudioChannel>(aChannel), channelName);
-  }
-
-  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-  if (obs) {
-    obs->NotifyObservers(nullptr, "default-volume-channel-changed",
-                         channelName.get());
-  }
+  mTelephonyChildren.AppendElement(TelephonyChild(aChildID));
 }
 
-/* static */ PLDHashOperator
-AudioChannelService::NotifyEnumerator(AudioChannelAgent* aAgent,
-                                      AudioChannel* aAudioChannel,
-                                      void* aUnused)
+void
+AudioChannelService::UnregisterTelephonyChild(uint64_t aChildID)
 {
-  aAgent->WindowVolumeChanged();
-  return PL_DHASH_NEXT;
-}
+  for (uint32_t i = 0, len = mTelephonyChildren.Length(); i < len; ++i) {
+    if (mTelephonyChildren[i].mChildID == aChildID) {
+      if (!--mTelephonyChildren[i].mInstances) {
+        mTelephonyChildren.RemoveElementAt(i);
+      }
 
+      return;
+    }
+  }
+
+  MOZ_ASSERT(false, "This should not happen.");
+}
diff --git a/dom/audiochannel/AudioChannelService.h b/dom/audiochannel/AudioChannelService.h
index 2ff391a9365..8e20c92b53e 100644
--- a/dom/audiochannel/AudioChannelService.h
+++ b/dom/audiochannel/AudioChannelService.h
@@ -7,11 +7,12 @@
 #ifndef mozilla_dom_audiochannelservice_h__
 #define mozilla_dom_audiochannelservice_h__
 
-#include "nsIAudioChannelService.h"
 #include "nsAutoPtr.h"
 #include "nsIObserver.h"
 #include "nsTArray.h"
+#include "nsITimer.h"
 
+#include "AudioChannelCommon.h"
 #include "AudioChannelAgent.h"
 #include "nsAttrValue.h"
 #include "nsClassHashtable.h"
@@ -25,23 +26,27 @@ namespace dom {
 #ifdef MOZ_WIDGET_GONK
 class SpeakerManagerService;
 #endif
-
-#define NUMBER_OF_AUDIO_CHANNELS (uint32_t)AudioChannel::Publicnotification + 1
-
-class AudioChannelService final : public nsIAudioChannelService
-                                , public nsIObserver
+class AudioChannelService
+: public nsIObserver
+, public nsITimerCallback
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOBSERVER
-  NS_DECL_NSIAUDIOCHANNELSERVICE
+  NS_DECL_NSITIMERCALLBACK
+
+  /**
+   * Returns the AudioChannelServce singleton or null if the process havn't create it before.
+   * Only to be called from main thread.
+   */
+  static AudioChannelService* GetAudioChannelService();
 
   /**
    * Returns the AudioChannelServce singleton.
    * If AudioChannelServce is not exist, create and return new one.
    * Only to be called from main thread.
    */
-  static already_AddRefed<AudioChannelService> GetOrCreate();
+  static AudioChannelService* GetOrCreateAudioChannelService();
 
   /**
    * Shutdown the singleton.
@@ -52,45 +57,40 @@ public:
    * Any audio channel agent that starts playing should register itself to
    * this service, sharing the AudioChannel.
    */
-  void RegisterAudioChannelAgent(AudioChannelAgent* aAgent, AudioChannel aChannel);
+  virtual void RegisterAudioChannelAgent(AudioChannelAgent* aAgent,
+                                         AudioChannel aChannel,
+                                         bool aWithVideo);
 
   /**
    * Any audio channel agent that stops playing should unregister itself to
    * this service.
    */
-  void UnregisterAudioChannelAgent(AudioChannelAgent* aAgent);
+  virtual void UnregisterAudioChannelAgent(AudioChannelAgent* aAgent);
 
   /**
-   * Return the state to indicate this audioChannel for his window should keep
-   * playing/muted.
+   * Return the state to indicate this agent should keep playing/
+   * fading volume/muted.
    */
-  void GetState(nsPIDOMWindow* aWindow, uint32_t aChannel,
-                float* aVolume, bool* aMuted);
+  virtual AudioChannelState GetState(AudioChannelAgent* aAgent,
+                                     bool aElementHidden);
 
-  /* Methods for the BrowserElementAudioChannel */
-  float GetAudioChannelVolume(nsPIDOMWindow* aWindow, AudioChannel aChannel);
-
-  void SetAudioChannelVolume(nsPIDOMWindow* aWindow, AudioChannel aChannel,
-                             float aVolume);
-
-  bool GetAudioChannelMuted(nsPIDOMWindow* aWindow, AudioChannel aChannel);
-
-  void SetAudioChannelMuted(nsPIDOMWindow* aWindow, AudioChannel aChannel,
-                            bool aMuted);
-
-  bool IsAudioChannelActive(nsPIDOMWindow* aWindow, AudioChannel aChannel);
+  /**
+   * Return true if there is a content channel active in this process
+   * or one of its subprocesses.
+   */
+  virtual bool ContentOrNormalChannelIsActive();
 
   /**
    * Return true if there is a telephony channel active in this process
    * or one of its subprocesses.
    */
-  bool TelephonyChannelIsActive();
+  virtual bool TelephonyChannelIsActive();
 
   /**
    * Return true if a normal or content channel is active for the given
    * process ID.
    */
-  bool ProcessContentOrNormalChannelIsActive(uint64_t aChildID);
+  virtual bool ProcessContentOrNormalChannelIsActive(uint64_t aChildID);
 
   /***
    * AudioChannelManager calls this function to notify the default channel used
@@ -125,69 +125,161 @@ public:
   static void GetAudioChannelString(AudioChannel aChannel, nsAString& aString);
   static void GetDefaultAudioChannelString(nsAString& aString);
 
-  void Notify(uint64_t aWindowID);
+  void Notify();
 
-private:
-  AudioChannelService();
-  ~AudioChannelService();
+protected:
+  void SendNotification();
+
+  /**
+   * Send the audio-channel-changed notification for the given process ID if
+   * needed.
+   */
+  void SendAudioChannelChangedNotification(uint64_t aChildID);
+
+  /* Register/Unregister IPC types: */
+  void RegisterType(AudioChannel aChannel, uint64_t aChildID, bool aWithVideo);
+  void UnregisterType(AudioChannel aChannel, bool aElementHidden,
+                      uint64_t aChildID, bool aWithVideo);
+  void UnregisterTypeInternal(AudioChannel aChannel, bool aElementHidden,
+                              uint64_t aChildID, bool aWithVideo);
+
+  AudioChannelState GetStateInternal(AudioChannel aChannel, uint64_t aChildID,
+                                     bool aElementHidden,
+                                     bool aElementWasHidden);
+
+  /* Update the internal type value following the visibility changes */
+  void UpdateChannelType(AudioChannel aChannel, uint64_t aChildID,
+                         bool aElementHidden, bool aElementWasHidden);
 
   /* Send the default-volume-channel-changed notification */
   void SetDefaultVolumeControlChannelInternal(int32_t aChannel,
                                               bool aVisible, uint64_t aChildID);
 
-  struct AudioChannelConfig final
-  {
-    AudioChannelConfig()
-      : mVolume(1.0)
-      , mMuted(false)
-      , mNumberOfAgents(0)
+  AudioChannelState CheckTelephonyPolicy(AudioChannel aChannel,
+                                         uint64_t aChildID);
+  void RegisterTelephonyChild(uint64_t aChildID);
+  void UnregisterTelephonyChild(uint64_t aChildID);
+
+  AudioChannelService();
+  virtual ~AudioChannelService();
+
+  enum AudioChannelInternalType {
+    AUDIO_CHANNEL_INT_NORMAL = 0,
+    AUDIO_CHANNEL_INT_NORMAL_HIDDEN,
+    AUDIO_CHANNEL_INT_CONTENT,
+    AUDIO_CHANNEL_INT_CONTENT_HIDDEN,
+    AUDIO_CHANNEL_INT_NOTIFICATION,
+    AUDIO_CHANNEL_INT_NOTIFICATION_HIDDEN,
+    AUDIO_CHANNEL_INT_ALARM,
+    AUDIO_CHANNEL_INT_ALARM_HIDDEN,
+    AUDIO_CHANNEL_INT_TELEPHONY,
+    AUDIO_CHANNEL_INT_TELEPHONY_HIDDEN,
+    AUDIO_CHANNEL_INT_RINGER,
+    AUDIO_CHANNEL_INT_RINGER_HIDDEN,
+    AUDIO_CHANNEL_INT_PUBLICNOTIFICATION,
+    AUDIO_CHANNEL_INT_PUBLICNOTIFICATION_HIDDEN,
+    AUDIO_CHANNEL_INT_LAST
+  };
+
+  bool ChannelsActiveWithHigherPriorityThan(AudioChannelInternalType aType);
+
+  bool CheckVolumeFadedCondition(AudioChannelInternalType aType,
+                                 bool aElementHidden);
+
+  AudioChannelInternalType GetInternalType(AudioChannel aChannel,
+                                           bool aElementHidden);
+
+  class AudioChannelAgentData {
+  public:
+    AudioChannelAgentData(AudioChannel aChannel,
+                          bool aElementHidden,
+                          AudioChannelState aState,
+                          bool aWithVideo)
+    : mChannel(aChannel)
+    , mElementHidden(aElementHidden)
+    , mState(aState)
+    , mWithVideo(aWithVideo)
     {}
 
-    float mVolume;
-    bool mMuted;
-
-    uint32_t mNumberOfAgents;
+    AudioChannel mChannel;
+    bool mElementHidden;
+    AudioChannelState mState;
+    const bool mWithVideo;
   };
 
-  struct AudioChannelWindow final
-  {
-    AudioChannelConfig mChannels[NUMBER_OF_AUDIO_CHANNELS];
-    nsClassHashtable<nsPtrHashKey<AudioChannelAgent>, AudioChannel> mAgents;
-  };
-
-  AudioChannelWindow&
-  GetOrCreateWindowData(nsPIDOMWindow* aWindow);
-
-  static PLDHashOperator
-  TelephonyChannelIsActiveEnumerator(const uint64_t& aWindowID,
-                                     nsAutoPtr<AudioChannelWindow>& aWinData,
-                                     void *aPtr);
-
-  static PLDHashOperator
-  AnyAudioChannelIsActiveEnumerator(const uint64_t& aWindowID,
-                                    nsAutoPtr<AudioChannelWindow>& aWinData,
-                                    void *aPtr);
-
-  static PLDHashOperator
-  RefreshAgentsVolumeEnumerator(AudioChannelAgent* aAgent,
-                                AudioChannel* aUnused,
-                                void *aPtr);
-
   static PLDHashOperator
   NotifyEnumerator(AudioChannelAgent* aAgent,
-                   AudioChannel* aAudioChannel,
-                   void* aUnused);
+                   AudioChannelAgentData* aData, void *aUnused);
 
-  nsClassHashtable<nsUint64HashKey, AudioChannelWindow> mWindows;
+  static PLDHashOperator
+  RefreshAgentsVolumeEnumerator(AudioChannelAgent* aAgent,
+                                AudioChannelAgentData* aUnused,
+                                void *aPtr);
 
+  static PLDHashOperator
+  CountWindowEnumerator(AudioChannelAgent* aAgent,
+                        AudioChannelAgentData* aUnused,
+                        void *aPtr);
+
+  static PLDHashOperator
+  WindowDestroyedEnumerator(AudioChannelAgent* aAgent,
+                            nsAutoPtr<AudioChannelAgentData>& aData,
+                            void *aPtr);
+
+  // This returns the number of agents from this aWindow.
+  uint32_t CountWindow(nsIDOMWindow* aWindow);
+
+  nsClassHashtable< nsPtrHashKey<AudioChannelAgent>, AudioChannelAgentData > mAgents;
 #ifdef MOZ_WIDGET_GONK
   nsTArray<SpeakerManagerService*>  mSpeakerManager;
 #endif
+  nsTArray<uint64_t> mChannelCounters[AUDIO_CHANNEL_INT_LAST];
+
+  int32_t mCurrentHigherChannel;
+  int32_t mCurrentVisibleHigherChannel;
+
+  nsTArray<uint64_t> mWithVideoChildIDs;
+
+  // Telephony Channel policy is "LIFO", the last app to require the resource is
+  // allowed to play. The others are muted.
+  struct TelephonyChild {
+    uint64_t mChildID;
+    uint32_t mInstances;
+
+    explicit TelephonyChild(uint64_t aChildID)
+      : mChildID(aChildID)
+      , mInstances(1)
+    {}
+  };
+  nsTArray<TelephonyChild> mTelephonyChildren;
+
+  // mPlayableHiddenContentChildID stores the ChildID of the process which can
+  // play content channel(s) in the background.
+  // A background process contained content channel(s) will become playable:
+  //   1. When this background process registers its content channel(s) in
+  //   AudioChannelService and there is no foreground process with registered
+  //   content channel(s).
+  //   2. When this process goes from foreground into background and there is
+  //   no foreground process with registered content channel(s).
+  // A background process contained content channel(s) will become non-playable:
+  //   1. When there is a foreground process registering its content channel(s)
+  //   in AudioChannelService.
+  //   ps. Currently this condition is never satisfied because the default value
+  //   of visibility status of each channel during registering is hidden = true.
+  //   2. When there is a process with registered content channel(s) goes from
+  //   background into foreground.
+  //   3. When this process unregisters all hidden content channels.
+  //   4. When this process shuts down.
+  uint64_t mPlayableHiddenContentChildID;
 
   bool mDisabled;
 
   nsCOMPtr<nsIRunnable> mRunnable;
 
+  nsCOMPtr<nsITimer> mDeferTelChannelTimer;
+  bool mTimerElementHidden;
+  uint64_t mTimerChildID;
+
   uint64_t mDefChannelChildID;
 
   // This is needed for IPC comunication between
diff --git a/dom/audiochannel/AudioChannelServiceChild.cpp b/dom/audiochannel/AudioChannelServiceChild.cpp
new file mode 100644
index 00000000000..ba23feb8ba7
--- /dev/null
+++ b/dom/audiochannel/AudioChannelServiceChild.cpp
@@ -0,0 +1,168 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "AudioChannelServiceChild.h"
+
+#include "base/basictypes.h"
+
+#include "mozilla/Services.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/unused.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "nsIObserverService.h"
+#include "nsThreadUtils.h"
+
+#ifdef MOZ_WIDGET_GONK
+#include "SpeakerManagerService.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::hal;
+
+StaticRefPtr<AudioChannelServiceChild> gAudioChannelServiceChild;
+
+// static
+AudioChannelService*
+AudioChannelServiceChild::GetAudioChannelService()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return gAudioChannelServiceChild;
+
+}
+
+// static
+AudioChannelService*
+AudioChannelServiceChild::GetOrCreateAudioChannelService()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // If we already exist, exit early
+  if (gAudioChannelServiceChild) {
+    return gAudioChannelServiceChild;
+  }
+
+  // Create new instance, register, return
+  nsRefPtr<AudioChannelServiceChild> service = new AudioChannelServiceChild();
+  MOZ_ASSERT(service);
+
+  gAudioChannelServiceChild = service;
+  return gAudioChannelServiceChild;
+}
+
+void
+AudioChannelServiceChild::Shutdown()
+{
+  if (gAudioChannelServiceChild) {
+    gAudioChannelServiceChild = nullptr;
+  }
+}
+
+AudioChannelServiceChild::AudioChannelServiceChild()
+{
+}
+
+AudioChannelServiceChild::~AudioChannelServiceChild()
+{
+}
+
+AudioChannelState
+AudioChannelServiceChild::GetState(AudioChannelAgent* aAgent, bool aElementHidden)
+{
+  AudioChannelAgentData* data;
+  if (!mAgents.Get(aAgent, &data)) {
+    return AUDIO_CHANNEL_STATE_MUTED;
+  }
+
+  AudioChannelState state = AUDIO_CHANNEL_STATE_MUTED;
+  bool oldElementHidden = data->mElementHidden;
+
+  UpdateChannelType(data->mChannel, CONTENT_PROCESS_ID_MAIN, aElementHidden,
+                    oldElementHidden);
+
+  // Update visibility.
+  data->mElementHidden = aElementHidden;
+
+  ContentChild* cc = ContentChild::GetSingleton();
+  cc->SendAudioChannelGetState(data->mChannel, aElementHidden, oldElementHidden,
+                               &state);
+  data->mState = state;
+  cc->SendAudioChannelChangedNotification();
+
+  #ifdef MOZ_WIDGET_GONK
+  /** Only modify the speaker status when
+   *  (1) apps in the foreground.
+   *  (2) apps in the backgrund and inactive.
+   *  Notice : modify only when the visible status is stable, because there
+   *  has lantency in passing the visibility events.
+   **/
+  bool active = AnyAudioChannelIsActive();
+  if (aElementHidden == oldElementHidden &&
+      (!aElementHidden || (aElementHidden && !active))) {
+    for (uint32_t i = 0; i < mSpeakerManager.Length(); i++) {
+      mSpeakerManager[i]->SetAudioChannelActive(active);
+    }
+  }
+  #endif
+
+  return state;
+}
+
+void
+AudioChannelServiceChild::RegisterAudioChannelAgent(AudioChannelAgent* aAgent,
+                                                    AudioChannel aChannel,
+                                                    bool aWithVideo)
+{
+  AudioChannelService::RegisterAudioChannelAgent(aAgent, aChannel, aWithVideo);
+
+  ContentChild::GetSingleton()->SendAudioChannelRegisterType(aChannel, aWithVideo);
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "audio-channel-agent-changed", nullptr);
+  }
+}
+
+void
+AudioChannelServiceChild::UnregisterAudioChannelAgent(AudioChannelAgent* aAgent)
+{
+  AudioChannelAgentData *pData;
+  if (!mAgents.Get(aAgent, &pData)) {
+    return;
+  }
+
+  // We need to keep a copy because unregister will remove the
+  // AudioChannelAgentData object from the hashtable.
+  AudioChannelAgentData data(*pData);
+
+  AudioChannelService::UnregisterAudioChannelAgent(aAgent);
+
+  ContentChild::GetSingleton()->SendAudioChannelUnregisterType(
+      data.mChannel, data.mElementHidden, data.mWithVideo);
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "audio-channel-agent-changed", nullptr);
+  }
+#ifdef MOZ_WIDGET_GONK
+  bool active = AnyAudioChannelIsActive();
+  for (uint32_t i = 0; i < mSpeakerManager.Length(); i++) {
+    mSpeakerManager[i]->SetAudioChannelActive(active);
+  }
+#endif
+}
+
+void
+AudioChannelServiceChild::SetDefaultVolumeControlChannel(int32_t aChannel,
+                                                         bool aHidden)
+{
+  ContentChild *cc = ContentChild::GetSingleton();
+  if (cc) {
+    cc->SendAudioChannelChangeDefVolChannel(aChannel, aHidden);
+  }
+}
diff --git a/dom/audiochannel/AudioChannelServiceChild.h b/dom/audiochannel/AudioChannelServiceChild.h
new file mode 100644
index 00000000000..503033495c5
--- /dev/null
+++ b/dom/audiochannel/AudioChannelServiceChild.h
@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_audiochannelservicechild_h__
+#define mozilla_dom_audiochannelservicechild_h__
+
+#include "nsAutoPtr.h"
+#include "nsISupports.h"
+
+#include "AudioChannelService.h"
+#include "AudioChannelCommon.h"
+
+namespace mozilla {
+namespace dom {
+
+class AudioChannelServiceChild : public AudioChannelService
+{
+public:
+
+  /**
+   * Returns the AudioChannelServce singleton or null if the process havn't create it before.
+   * Only to be called from main thread.
+   */
+  static AudioChannelService* GetAudioChannelService();
+
+  /**
+   * Returns the AudioChannelServce singleton.
+   * If AudioChannelServce is not exist, create and return new one.
+   * Only to be called from main thread.
+   */
+  static AudioChannelService* GetOrCreateAudioChannelService();
+
+  static void Shutdown();
+
+  virtual void RegisterAudioChannelAgent(AudioChannelAgent* aAgent,
+                                         AudioChannel aChannel,
+                                         bool aWithVideo);
+  virtual void UnregisterAudioChannelAgent(AudioChannelAgent* aAgent);
+
+  /**
+   * Return the state to indicate this agent should keep playing/
+   * fading volume/muted.
+   */
+  virtual AudioChannelState GetState(AudioChannelAgent* aAgent,
+                                     bool aElementHidden);
+
+  virtual void SetDefaultVolumeControlChannel(int32_t aChannel,
+                                              bool aHidden);
+
+protected:
+  AudioChannelServiceChild();
+  virtual ~AudioChannelServiceChild();
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif
+
diff --git a/dom/audiochannel/moz.build b/dom/audiochannel/moz.build
index cc8b71ffd0c..00803501bc4 100644
--- a/dom/audiochannel/moz.build
+++ b/dom/audiochannel/moz.build
@@ -4,21 +4,25 @@
 # 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/.
 
+TEST_DIRS += ['tests']
+
 XPIDL_SOURCES += [
     'nsIAudioChannelAgent.idl',
-    'nsIAudioChannelService.idl',
 ]
 
 XPIDL_MODULE = 'dom_audiochannel'
 
 EXPORTS += [
     'AudioChannelAgent.h',
+    'AudioChannelCommon.h',
     'AudioChannelService.h',
+    'AudioChannelServiceChild.h',
 ]
 
 UNIFIED_SOURCES += [
     'AudioChannelAgent.cpp',
     'AudioChannelService.cpp',
+    'AudioChannelServiceChild.cpp',
 ]
 
 FAIL_ON_WARNINGS = True
diff --git a/dom/audiochannel/nsIAudioChannelAgent.idl b/dom/audiochannel/nsIAudioChannelAgent.idl
index 8febf962fbd..e990d3959ab 100644
--- a/dom/audiochannel/nsIAudioChannelAgent.idl
+++ b/dom/audiochannel/nsIAudioChannelAgent.idl
@@ -6,13 +6,24 @@
 
 interface nsIDOMWindow;
 
-[uuid(4f537c88-3722-4946-9a09-ce559fa0591d)]
+[uuid(194b55d9-39c0-45c6-b8ef-b8049f978ea5)]
 interface nsIAudioChannelAgentCallback : nsISupports
 {
+  /**
+   * Notified when the playable status of channel is changed.
+   *
+   * @param canPlay
+   *        Callback from agent to notify component of the playable status
+   *        of the channel. If canPlay is muted state, component SHOULD stop
+   *        playing media associated with this channel as soon as possible. if
+   *        it is faded state then the volume of media should be reduced.
+   */
+  void canPlayChanged(in long canPlay);
+
   /**
    * Notified when the window volume/mute is changed
    */
-  void windowVolumeChanged(in float aVolume, in bool aMuted);
+  void windowVolumeChanged();
 };
 
 /**
@@ -29,7 +40,7 @@ interface nsIAudioChannelAgentCallback : nsISupports
  *   1. Changes to the playable status of this channel.
  */
 
-[uuid(363ff8d3-5bd2-485a-84ac-125062cbdc19)]
+[uuid(2b0222a5-8f7b-49d2-9ab8-cd01b744b23e)]
 interface nsIAudioChannelAgent : nsISupports
 {
   const long AUDIO_AGENT_CHANNEL_NORMAL             = 0;
@@ -80,6 +91,16 @@ interface nsIAudioChannelAgent : nsISupports
   void initWithWeakCallback(in nsIDOMWindow window, in long channelType,
                             in nsIAudioChannelAgentCallback callback);
 
+  /**
+   * This method is just like init(), and specify the channel is associated
+   * with video.
+   *
+   * @param weak
+   *    true if weak reference should be hold.
+   */
+  void initWithVideo(in nsIDOMWindow window, in long channelType,
+                     in nsIAudioChannelAgentCallback callback, in boolean weak);
+
   /**
    * Notify the agent that we want to start playing.
    * Note: Gecko component SHOULD call this function first then start to
@@ -94,7 +115,7 @@ interface nsIAudioChannelAgent : nsISupports
    *    faded state: the agent has registered with audio channel service the
    *          component should start playback as well as reducing the volume.
    */
-  void startPlaying(out float volume, out bool muted);
+  long startPlaying();
 
   /**
    * Notify the agent we no longer want to play.
@@ -105,4 +126,17 @@ interface nsIAudioChannelAgent : nsISupports
    *        channel service.
    */
   void stopPlaying();
+
+  /**
+   * Notify the agent of the visibility state of the window using this agent.
+   * @param visible
+   *    True if the window associated with the agent is visible.
+   */
+  void setVisibilityState(in boolean visible);
+
+  /**
+   * Retrieve the volume from the window.
+   */
+  readonly attribute float windowVolume;
 };
+
diff --git a/dom/audiochannel/nsIAudioChannelService.idl b/dom/audiochannel/nsIAudioChannelService.idl
deleted file mode 100644
index 8cdc0379d26..00000000000
--- a/dom/audiochannel/nsIAudioChannelService.idl
+++ /dev/null
@@ -1,29 +0,0 @@
-/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* 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/. */
-
-#include "nsISupports.idl"
-
-interface nsIDOMWindow;
-
-[scriptable, builtinclass, uuid(323e5472-b8f4-4288-b1b9-53c7c54bbbe8)]
-interface nsIAudioChannelService : nsISupports
-{
-  float getAudioChannelVolume(in nsIDOMWindow window,
-                              in unsigned short audioChannel);
-
-  void setAudioChannelVolume(in nsIDOMWindow window,
-                             in unsigned short audioChannel,
-                             in float volume);
-
-  boolean getAudioChannelMuted(in nsIDOMWindow window,
-                               in unsigned short audioChannel);
-
-  void setAudioChannelMuted(in nsIDOMWindow window,
-                            in unsigned short audioChannel,
-                            in boolean muted);
-
-  boolean isAudioChannelActive(in nsIDOMWindow window,
-                               in unsigned short audioChannel);
-};
diff --git a/dom/audiochannel/tests/AudioChannelChromeScript.js b/dom/audiochannel/tests/AudioChannelChromeScript.js
new file mode 100644
index 00000000000..46bd7d30791
--- /dev/null
+++ b/dom/audiochannel/tests/AudioChannelChromeScript.js
@@ -0,0 +1,18 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components;
+const { Services } = Cu.import('resource://gre/modules/Services.jsm');
+const { SystemAppProxy } = Cu.import('resource://gre/modules/SystemAppProxy.jsm');
+
+addMessageListener('init-chrome-event', function(message) {
+  // listen mozChromeEvent and forward to content process.
+  let type = message.type;
+
+  SystemAppProxy.addEventListener('mozChromeEvent', function(event) {
+    let details = event.detail;
+    if (details.type === type) {
+      sendAsyncMessage('chrome-event', details);
+    }
+  }, true);
+});
diff --git a/dom/audiochannel/tests/TestAudioChannelService.cpp b/dom/audiochannel/tests/TestAudioChannelService.cpp
new file mode 100644
index 00000000000..9d6a6d1a40d
--- /dev/null
+++ b/dom/audiochannel/tests/TestAudioChannelService.cpp
@@ -0,0 +1,669 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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"
+
+#include "nsWeakReference.h"
+#include "AudioChannelService.h"
+#include "AudioChannelAgent.h"
+
+#include "nsThreadUtils.h"
+
+#define TEST_ENSURE_BASE(_test, _msg)       \
+  PR_BEGIN_MACRO                            \
+    if (!(_test)) {                         \
+      fail(_msg);                           \
+      return NS_ERROR_FAILURE;              \
+    } else {                                \
+      passed(_msg);                         \
+    }                                       \
+  PR_END_MACRO
+
+using namespace mozilla::dom;
+
+void
+spin_events_loop_until_false(const bool* const aCondition)
+{
+  nsCOMPtr<nsIThread> thread(::do_GetCurrentThread());
+  nsresult rv = NS_OK;
+  bool processed = true;
+  while (*aCondition && NS_SUCCEEDED(rv)) {
+    rv = thread->ProcessNextEvent(true, &processed);
+  }
+}
+
+class Agent : public nsIAudioChannelAgentCallback,
+              public nsSupportsWeakReference
+{
+protected:
+  virtual ~Agent()
+  {
+    if (mRegistered) {
+      StopPlaying();
+    }
+  }
+
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit Agent(AudioChannel aChannel)
+  : mChannel(aChannel)
+  , mWaitCallback(false)
+  , mRegistered(false)
+  , mCanPlay(AUDIO_CHANNEL_STATE_MUTED)
+  {
+    mAgent = do_CreateInstance("@mozilla.org/audiochannelagent;1");
+  }
+
+  nsresult Init(bool video=false)
+  {
+    nsresult rv = NS_OK;
+    if (video) {
+      rv = mAgent->InitWithVideo(nullptr, static_cast<int32_t>(mChannel),
+                                 this, true);
+    }
+    else {
+      rv = mAgent->InitWithWeakCallback(nullptr, static_cast<int32_t>(mChannel),
+                                        this);
+    }
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return mAgent->SetVisibilityState(false);
+  }
+
+  nsresult StartPlaying(AudioChannelState *_ret)
+  {
+    if (mRegistered) {
+      StopPlaying();
+    }
+
+    nsresult rv = mAgent->StartPlaying((int32_t *)_ret);
+    mRegistered = true;
+    return rv;
+  }
+
+  nsresult StopPlaying()
+  {
+    mRegistered = false;
+    spin_events_loop_until_false(&mWaitCallback);
+    return mAgent->StopPlaying();
+  }
+
+  nsresult SetVisibilityState(bool visible)
+  {
+    if (mRegistered) {
+      mWaitCallback = true;
+    }
+    return mAgent->SetVisibilityState(visible);
+  }
+
+  NS_IMETHODIMP CanPlayChanged(int32_t canPlay) override
+  {
+    mCanPlay = static_cast<AudioChannelState>(canPlay);
+    mWaitCallback = false;
+    return NS_OK;
+  }
+
+  NS_IMETHODIMP WindowVolumeChanged() override
+  {
+    return NS_OK;
+  }
+
+  nsresult GetCanPlay(AudioChannelState *_ret, bool aWaitCallback = false)
+  {
+    if (aWaitCallback) {
+      mWaitCallback = true;
+    }
+
+    spin_events_loop_until_false(&mWaitCallback);
+    *_ret = mCanPlay;
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIAudioChannelAgent> mAgent;
+  AudioChannel mChannel;
+  bool mWaitCallback;
+  bool mRegistered;
+  AudioChannelState mCanPlay;
+};
+
+NS_IMPL_ISUPPORTS(Agent, nsIAudioChannelAgentCallback,
+                  nsISupportsWeakReference)
+
+nsresult
+TestDoubleStartPlaying()
+{
+  nsRefPtr<Agent> agent = new Agent(AudioChannel::Normal);
+
+  nsresult rv = agent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AudioChannelState playable;
+  rv = agent->mAgent->StartPlaying((int32_t *)&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent->mAgent->StartPlaying((int32_t *)&playable);
+  TEST_ENSURE_BASE(NS_FAILED(rv),
+    "Test0: StartPlaying calling twice must return error");
+
+  return NS_OK;
+}
+
+nsresult
+TestOneNormalChannel()
+{
+  nsRefPtr<Agent> agent = new Agent(AudioChannel::Normal);
+  nsresult rv = agent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AudioChannelState playable;
+  rv = agent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test1: A normal channel unvisible agent must be muted");
+
+  rv = agent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test1: A normal channel visible agent must be playable");
+
+  return rv;
+}
+
+nsresult
+TestTwoNormalChannels()
+{
+  nsRefPtr<Agent> agent1 = new Agent(AudioChannel::Normal);
+  nsresult rv = agent1->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> agent2 = new Agent(AudioChannel::Normal);
+  rv = agent2->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AudioChannelState playable;
+  rv = agent1->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test2: A normal channel unvisible agent1 must be muted");
+
+  rv = agent2->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test2: A normal channel unvisible agent2 must be muted");
+
+  rv = agent1->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent2->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent1->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test2: A normal channel visible agent1 must be playable");
+
+  rv = agent2->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test2: A normal channel visible agent2 must be playable");
+
+  return rv;
+}
+
+nsresult
+TestContentChannels()
+{
+  nsRefPtr<Agent> agent1 = new Agent(AudioChannel::Content);
+  nsresult rv = agent1->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> agent2 = new Agent(AudioChannel::Content);
+  rv = agent2->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // All content channels in the foreground can be allowed to play
+  rv = agent1->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent2->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AudioChannelState playable;
+  rv = agent1->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test3: A content channel visible agent1 must be playable");
+
+  rv = agent2->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test3: A content channel visible agent2 must be playable");
+
+  // 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(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test3: A content channel unvisible agent1 must be playable from "
+    "foreground to background");
+
+  // Test all content channels set non-visible already
+  rv = agent2->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent2->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test3: A content channel unvisible agent2 must be playable from "
+    "foreground to background");
+
+  // Clear the content channels & mActiveContentChildIDs in AudioChannelService.
+  // If agent stop playable 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 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(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test3: A content channel unvisible agent1 must be playable "
+    "from background state");
+
+  rv = agent2->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test3: A content channel unvisible agent2 must be playable "
+    "from background state");
+
+  return rv;
+}
+
+nsresult
+TestFadedState()
+{
+  nsRefPtr<Agent> normalAgent = new Agent(AudioChannel::Normal);
+  nsresult rv = normalAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> contentAgent = new Agent(AudioChannel::Content);
+  rv = contentAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> notificationAgent = new Agent(AudioChannel::Notification);
+  rv = notificationAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = normalAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = contentAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = notificationAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AudioChannelState playable;
+  rv = normalAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test4: A normal channel visible agent must be playable");
+
+  rv = contentAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test4: A content channel visible agent must be playable");
+
+  rv = notificationAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test4: A notification channel visible agent must be playable");
+
+  rv = contentAgent->GetCanPlay(&playable, true);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_FADED,
+    "Test4: A content channel unvisible agent must be faded because of "
+    "notification channel is playing");
+
+  rv = contentAgent->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = contentAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_FADED,
+    "Test4: A content channel unvisible agent must be faded because of "
+    "notification channel is playing");
+
+  rv = notificationAgent->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = notificationAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test4: A notification channel unvisible agent must be playable from "
+    "foreground to background");
+
+  rv = notificationAgent->StopPlaying();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = contentAgent->GetCanPlay(&playable, true);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test4: A content channel unvisible agent must be playable "
+    "because of notification channel is stopped");
+
+  rv = contentAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return rv;
+}
+
+nsresult
+TestPriorities()
+{
+  nsRefPtr<Agent> normalAgent = new Agent(AudioChannel::Normal);
+  nsresult rv = normalAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> contentAgent = new Agent(AudioChannel::Content);
+  rv = contentAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> notificationAgent = new Agent(AudioChannel::Notification);
+  rv = notificationAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> alarmAgent = new Agent(AudioChannel::Alarm);
+  rv = alarmAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> telephonyAgent = new Agent(AudioChannel::Telephony);
+  rv = telephonyAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> ringerAgent = new Agent(AudioChannel::Ringer);
+  rv = ringerAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> pNotificationAgent =
+    new Agent(AudioChannel::Publicnotification);
+  rv = pNotificationAgent->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AudioChannelState playable;
+
+  rv = normalAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test5: A normal channel unvisible agent must be muted");
+
+  rv = contentAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A content channel unvisible agent must be playable while "
+    "playing from background state");
+
+  rv = notificationAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A notification channel unvisible agent must be playable");
+
+  rv = alarmAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: An alarm channel unvisible agent must be playable");
+
+  rv = notificationAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test5: A notification channel unvisible agent must be muted when an "
+    "alarm is playing");
+
+  rv = telephonyAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A telephony channel unvisible agent must be playable");
+
+  rv = alarmAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test5: An alarm channel unvisible agent must be muted when a telephony "
+    "is playing");
+
+  rv = ringerAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A ringer channel unvisible agent must be playable");
+
+  rv = telephonyAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test5: A telephony channel unvisible agent must be muted when a ringer "
+    "is playing");
+
+  rv = pNotificationAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A pNotification channel unvisible agent must be playable");
+
+  rv = ringerAgent->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test5: A ringer channel unvisible agent must be muted when a public "
+    "notification is playing");
+
+  // Stop to play notification channel or normal/content will be faded.
+  // Which already be tested on Test 4.
+  rv = notificationAgent->StopPlaying();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Settings visible the normal channel.
+  rv = normalAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = normalAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A normal channel visible agent must be playable");
+
+  // Set the content channel as visible .
+  rv = contentAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Content must be playable because visible.
+  rv = contentAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A content channel visible agent must be playable");
+
+  // Set the alarm channel as visible.
+  rv = alarmAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = alarmAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: An alarm channel visible agent must be playable");
+
+  // Set the telephony channel as visible.
+  rv = telephonyAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = telephonyAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A telephony channel visible agent must be playable");
+
+  // Set the ringer channel as visible.
+  rv = ringerAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = ringerAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A ringer channel visible agent must be playable");
+
+  // Set the public notification channel as visible.
+  rv = pNotificationAgent->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = pNotificationAgent->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test5: A pNotification channel visible agent must be playable");
+
+  return rv;
+}
+
+nsresult
+TestOneVideoNormalChannel()
+{
+  nsRefPtr<Agent> agent1 = new Agent(AudioChannel::Normal);
+  nsresult rv = agent1->Init(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<Agent> agent2 = new Agent(AudioChannel::Content);
+  rv = agent2->Init(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AudioChannelState playable;
+  rv = agent1->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test6: A video normal channel invisible agent1 must be muted");
+
+  rv = agent2->StartPlaying(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test6: A content channel invisible agent2 must be playable");
+
+  // one video normal channel in foreground and one content channel in background
+  rv = agent1->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent1->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test6: A video normal channel visible agent1 must be playable");
+
+  rv = agent2->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test6: A content channel invisible agent2 must be muted");
+
+  // both one video normal channel and one content channel in foreground
+  rv = agent2->SetVisibilityState(true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent1->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test6: A video normal channel visible agent1 must be playable");
+
+  rv = agent2->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test6: A content channel visible agent2 must be playable");
+
+  // one video normal channel in background and one content channel in foreground
+  rv = agent1->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent1->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test6: A video normal channel invisible agent1 must be muted");
+
+  rv = agent2->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test6: A content channel visible agent2 must be playable");
+
+  // both one video normal channel and one content channel in background
+  rv = agent2->SetVisibilityState(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = agent1->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_MUTED,
+    "Test6: A video normal channel invisible agent1 must be muted");
+
+  rv = agent2->GetCanPlay(&playable);
+  NS_ENSURE_SUCCESS(rv, rv);
+  TEST_ENSURE_BASE(playable == AUDIO_CHANNEL_STATE_NORMAL,
+    "Test6: A content channel invisible agent2 must be playable");
+
+  return rv;
+}
+
+int main(int argc, char** argv)
+{
+  ScopedXPCOM xpcom("AudioChannelService");
+  if (xpcom.failed()) {
+    return 1;
+  }
+
+  if (NS_FAILED(TestDoubleStartPlaying())) {
+    return 1;
+  }
+
+  if (NS_FAILED(TestOneNormalChannel())) {
+    return 1;
+  }
+
+  if (NS_FAILED(TestTwoNormalChannels())) {
+    return 1;
+  }
+
+  if (NS_FAILED(TestContentChannels())) {
+    return 1;
+  }
+
+  if (NS_FAILED(TestFadedState())) {
+    return 1;
+  }
+
+  // Channel type with AudioChannel::Telephony cannot be unregistered until the
+  // main thread has chances to process 1500 millisecond timer. In order to
+  // skip ambiguous return value of ChannelsActiveWithHigherPriorityThan(), new
+  // test cases are added before any test case that registers the channel type
+  // with AudioChannel::Telephony channel.
+  if (NS_FAILED(TestOneVideoNormalChannel())) {
+    return 1;
+  }
+
+  if (NS_FAILED(TestPriorities())) {
+    return 1;
+  }
+
+  return 0;
+}
+
diff --git a/dom/audiochannel/tests/audio.ogg b/dom/audiochannel/tests/audio.ogg
new file mode 100644
index 00000000000..d7f6a0ccf47
Binary files /dev/null and b/dom/audiochannel/tests/audio.ogg differ
diff --git a/dom/audiochannel/tests/file_audio.html b/dom/audiochannel/tests/file_audio.html
new file mode 100644
index 00000000000..11058a1ff11
--- /dev/null
+++ b/dom/audiochannel/tests/file_audio.html
@@ -0,0 +1,99 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test audio-channel-changed & visible-audio-channel-changed mozChromeEvent</title>
+</head>
+<body>
+  <div id="content"></div>
+  <script>
+  var normalAudio;
+  var contentAudio;
+  var notificationAudio;
+  var alarmAudio;
+  var telephonyAudio;
+  var ringerAudio;
+  var publicnotificationAudio;
+
+  function playWithAudioType(audio, type) {
+    audio.mozAudioChannelType = type;
+    audio.src = "test.ogg";
+    audio.loop = true;
+
+    audio.play();
+  }
+
+  function runTest() {
+    // normal channel.
+    normalAudio = new Audio();
+    playWithAudioType(normalAudio, 'normal');
+
+    // content channel.
+    contentAudio = new Audio();
+    playWithAudioType(contentAudio, 'content');
+
+    // notification channel.
+    notificationAudio = new Audio();
+    playWithAudioType(notificationAudio, 'notification');
+
+    // alarm channel.
+    alarmAudio = new Audio();
+    playWithAudioType(alarmAudio, 'alarm');
+
+    // telephony channel.
+    telephonyAudio = new Audio();
+    playWithAudioType(telephonyAudio, 'telephony');
+
+    // ringer channel.
+    ringerAudio = new Audio();
+    playWithAudioType(ringerAudio, 'ringer');
+
+    // publicnotification channel.
+    publicnotificationAudio = new Audio();
+    playWithAudioType(publicnotificationAudio, 'publicnotification');
+
+    window.addEventListener('hashchange', function(event) {
+      if (location.hash == "#pauseAudio") {
+        publicnotificationAudio.pause();
+        ringerAudio.pause();
+        telephonyAudio.pause();
+      }
+
+      if (location.hash == "#pauseAudioFollowing") {
+        alarmAudio.pause();
+        notificationAudio.pause();
+        contentAudio.pause();
+        normalAudio.pause();
+      }
+    }, false);
+  }
+
+  function checkBackgroundStatus() {
+    if (location.hash == "#fg") {
+      runTest();
+      return;
+    }
+
+    if (document.hidden) {
+      runTest();
+      return;
+    }
+
+    document.addEventListener('visibilitychange', function visibilityChange() {
+      if (document.hidden) {
+        runTest();
+      }
+    });
+  }
+
+  SpecialPowers.pushPermissions(
+    [{ "type": "audio-channel-content", "allow": 1, "context": document },
+     { "type": "audio-channel-notification", "allow": 1, "context": document },
+     { "type": "audio-channel-alarm", "allow": 1, "context": document },
+     { "type": "audio-channel-telephony", "allow": 1, "context": document },
+     { "type": "audio-channel-ringer", "allow": 1, "context": document },
+     { "type": "audio-channel-publicnotification", "allow": 1, "context": document }],
+    checkBackgroundStatus);
+
+  </script>
+</body>
+</html>
diff --git a/dom/audiochannel/tests/file_telephonyPolicy.html b/dom/audiochannel/tests/file_telephonyPolicy.html
new file mode 100644
index 00000000000..f95b7d40ff8
--- /dev/null
+++ b/dom/audiochannel/tests/file_telephonyPolicy.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test Telephony Channel Policy</title>
+</head>
+<body>
+<div id="container"></div>
+  <script type="application/javascript;version=1.7">
+
+  var audio = new Audio();
+  audio.mozAudioChannelType = 'telephony';
+  audio.src = "audio.ogg";
+  audio.play();
+
+  </script>
+</body>
+</html>
diff --git a/dom/audiochannel/tests/mochitest.ini b/dom/audiochannel/tests/mochitest.ini
new file mode 100644
index 00000000000..45564d6dd46
--- /dev/null
+++ b/dom/audiochannel/tests/mochitest.ini
@@ -0,0 +1,11 @@
+[DEFAULT]
+support-files =
+  audio.ogg
+  file_audio.html
+  file_telephonyPolicy.html
+  AudioChannelChromeScript.js
+
+[test_telephonyPolicy.html]
+skip-if = buildapp == 'mulet' || (toolkit == 'gonk' || e10s) || os == "android"
+[test_audioChannelChange.html]
+skip-if = (toolkit != 'gonk')
diff --git a/dom/audiochannel/tests/moz.build b/dom/audiochannel/tests/moz.build
new file mode 100644
index 00000000000..b1bf003ce18
--- /dev/null
+++ b/dom/audiochannel/tests/moz.build
@@ -0,0 +1,16 @@
+# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+GeckoCppUnitTests([
+    'TestAudioChannelService',
+])
+
+if CONFIG['OS_ARCH'] == 'WINNT':
+    DEFINES['NOMINMAX'] = True
+
+MOCHITEST_MANIFESTS += ['mochitest.ini']
+
+FAIL_ON_WARNINGS = True
diff --git a/dom/audiochannel/tests/test_audioChannelChange.html b/dom/audiochannel/tests/test_audioChannelChange.html
new file mode 100644
index 00000000000..1036018047f
--- /dev/null
+++ b/dom/audiochannel/tests/test_audioChannelChange.html
@@ -0,0 +1,209 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test audio-channel-changed & visible-audio-channel-changed mozChromeEvent</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+  <div id="content"></div>
+  <script type="application/javascript;version=1.7">
+  var expectedAudioTypes;
+  var expectedVisibleAudioTypes;
+  var expectedVisibleAudioType;
+  var index;
+  var visibleIndex;
+  var iframe1;
+  var normalAudio;
+
+  function playWithAudioType(audio, type) {
+    audio.mozAudioChannelType = type;
+    audio.src = "test.ogg";
+    audio.loop = true;
+
+    audio.play();
+  }
+
+  function fgBgTestListener(message) {
+    var type = message.type;
+    var channel = message.channel;
+
+    if (type == 'audio-channel-changed') {
+      is(channel, expectedAudioTypes[index], channel + " is received and expected " + expectedAudioTypes[index]);
+      index++;
+    }
+
+    if (type == 'visible-audio-channel-changed') {
+      is(channel, expectedVisibleAudioType, channel + " is received and expected " + expectedVisibleAudioType);
+    }
+
+    // All audio types are playing now so ask to pause them.
+    // This call will stop audio from highest to telephony.
+    if ('cmd-pause' == expectedAudioTypes[index]) {
+      iframe1.src = 'file_audio.html#pauseAudio';
+      index++;
+    }
+
+    // According to there is a 1.5 second delay of releasing telephony,
+    // we need to wait for it then continue to pause others.
+    if ('cmd-secondPause' == expectedAudioTypes[index]) {
+      iframe1.src = 'file_audio.html#pauseAudioFollowing';
+      index++;
+    }
+
+    if (index == expectedAudioTypes.length) {
+      document.body.removeChild(iframe1);
+      script.removeMessageListener('chrome-event', fgBgTestListener);
+      normalAudio.pause();
+      SimpleTest.finish();
+    }
+  }
+
+  // Channel of visible-audio-channel-changed event should be always normal.
+  // Audios in background should not effect visible-audio-channel-changed.
+  function runFgBgTest() {
+    expectedAudioTypes = ["normal", "content", "notification",
+                          "alarm", "telephony", "ringer", "publicnotification", "cmd-pause",
+                          "ringer", "telephony", "alarm", "cmd-secondPause", "notification",
+                          "content", "normal"];
+    expectedVisibleAudioType = "normal";
+    index = 0;
+
+    script.addMessageListener('chrome-event', fgBgTestListener);
+
+    // To play a audio with normal channel in the foreground.
+    normalAudio = new Audio();
+    playWithAudioType(normalAudio, 'normal');
+
+    iframe1.src = 'file_audio.html#bg';
+    document.body.appendChild(iframe1);
+    iframe1.setVisible(false);
+  }
+
+  function bgTestListener(message) {
+    var type = message.type;
+    var channel = message.channel;
+
+    if (type == 'audio-channel-changed') {
+      is(channel, expectedAudioTypes[index], channel + " is received and expected " + expectedAudioTypes[index]);
+      index++;
+    }
+
+    if (type == 'visible-audio-channel-changed') {
+      is(channel, expectedVisibleAudioType, channel + " is received and expected " + expectedVisibleAudioType);
+    }
+
+    // All audio types are playing now so ask to pause them.
+    if ('cmd-pause' == expectedAudioTypes[index]) {
+      iframe1.src = 'file_audio.html#pauseAudio';
+      index++;
+    }
+
+    if ('cmd-secondPause' == expectedAudioTypes[index]) {
+      iframe1.src = 'file_audio.html#pauseAudioFollowing';
+      index++;
+    }
+
+    if (index == expectedAudioTypes.length) {
+      document.body.removeChild(iframe1);
+      script.removeMessageListener('chrome-event', bgTestListener);
+      runFgBgTest();
+    }
+  }
+
+  // 1. Channel of visible-audio-channel-changed event should be always none.
+  // 2. normal is not allowed to be played in the background.
+  function runBgTest() {
+    expectedAudioTypes = ["content", "notification",
+                          "alarm", "telephony", "ringer", "publicnotification", "cmd-pause",
+                         "ringer", "telephony", "alarm", "cmd-secondPause", "notification",
+                          "content", "none"];
+    expectedVisibleAudioType = "none";
+    index = 0;
+
+    script.addMessageListener('chrome-event', bgTestListener);
+
+    iframe1.src = 'file_audio.html#bg';
+    document.body.appendChild(iframe1);
+    iframe1.setVisible(false);
+  }
+
+  function fgTestListener(message) {
+    var type = message.type;
+    var channel = message.channel;
+
+    if (type == 'audio-channel-changed') {
+      is(channel, expectedAudioTypes[index], channel + " is received and expected " + expectedAudioTypes[index]);
+      index++;
+    }
+
+    if (type == 'visible-audio-channel-changed') {
+      is(channel, expectedAudioTypes[visibleIndex], channel + " is received and expected " + expectedAudioTypes[visibleIndex]);
+      visibleIndex++;
+    }
+
+    // All audio types are playing now so ask to pause them.
+    if ('cmd-pause' == expectedAudioTypes[visibleIndex] &&
+        'cmd-pause' == expectedAudioTypes[index]) {
+      iframe1.src = 'file_audio.html#pauseAudio';
+      visibleIndex++;
+      index++;
+    }
+
+    if ('cmd-secondPause' == expectedAudioTypes[visibleIndex] &&
+        'cmd-secondPause' == expectedAudioTypes[index]) {
+      iframe1.src = 'file_audio.html#pauseAudioFollowing';
+      visibleIndex++;
+      index++;
+    }
+
+    if (index == expectedAudioTypes.length && visibleIndex == expectedAudioTypes.length) {
+      document.body.removeChild(iframe1);
+      script.removeMessageListener('chrome-event', fgTestListener);
+      runBgTest();
+    }
+  }
+
+  // The foreground audio will effect both of audio-channel-changed and
+  // visible-audio-channel-changed.
+  function runFgTest() {
+    expectedAudioTypes = ["normal", "content", "notification",
+                          "alarm", "telephony", "ringer", "publicnotification",
+                          "cmd-pause", "ringer", "telephony", "alarm",
+                          "cmd-secondPause", "notification", "content",
+                          "normal", "none"];
+
+    index = 0;
+    visibleIndex = 0;
+
+    script.addMessageListener('chrome-event', fgTestListener);
+
+    iframe1 = document.createElement('iframe');
+    iframe1.setAttribute('mozbrowser', true);
+    iframe1.src = 'file_audio.html#fg';
+    document.body.appendChild(iframe1);
+  }
+
+  var url = SimpleTest.getTestFileURL("AudioChannelChromeScript.js")
+  var script = SpecialPowers.loadChromeScript(url);
+  script.sendAsyncMessage("init-chrome-event", {
+    type: 'audio-channel-changed'
+  });
+  script.sendAsyncMessage("init-chrome-event", {
+    type: 'visible-audio-channel-changed'
+  });
+
+  SimpleTest.waitForExplicitFinish();
+
+  SpecialPowers.pushPermissions(
+    [{ "type": "browser", "allow": 1, "context": document },
+     { "type": "embed-apps", "allow": 1, "context": document },
+     { "type": "webapps-manage", "allow": 1, "context": document }], function() {
+    SpecialPowers.pushPrefEnv({"set": [["dom.ipc.browser_frames.oop_by_default", true],
+                                       ["media.useAudioChannelService", true],
+                                       ["dom.mozBrowserFramesEnabled", true]]}, runFgTest);
+  });
+  </script>
+</body>
+</html>
diff --git a/dom/audiochannel/tests/test_telephonyPolicy.html b/dom/audiochannel/tests/test_telephonyPolicy.html
new file mode 100644
index 00000000000..f0294ac3cf8
--- /dev/null
+++ b/dom/audiochannel/tests/test_telephonyPolicy.html
@@ -0,0 +1,87 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test the Telephony Channel Policy</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<div id="container"></div>
+  <script type="application/javascript;version=1.7">
+
+function mainApp() {
+  var audio = new Audio();
+  audio.mozAudioChannelType = 'telephony';
+  audio.src = "audio.ogg";
+  audio.loop = true;
+  audio.play();
+
+  audio.addEventListener('mozinterruptbegin', function() {
+    ok(true, "This element has been muted!");
+  }, false);
+
+  audio.addEventListener('mozinterruptend', function() {
+    ok(true, "This element has been unmuted!");
+    audio.pause();
+    runTest();
+  }, false);
+
+  setTimeout(runTest, 600);
+}
+
+function newApp() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  // That needs to be an app.
+  iframe.setAttribute('mozapp', 'https://acertified.com/manifest.webapp');
+  iframe.src = "file_telephonyPolicy.html";
+  document.body.appendChild(iframe);
+}
+
+var tests = [
+  // Permissions
+  function() {
+    SpecialPowers.pushPermissions(
+      [{ "type": "browser", "allow": 1, "context": document },
+       { "type": "embed-apps", "allow": 1, "context": document },
+       { "type": "webapps-manage", "allow": 1, "context": document },
+       { "type": "audio-channel-telephony", "allow": 1, "context": document }], runTest);
+  },
+
+  // Preferences
+  function() {
+    SpecialPowers.pushPrefEnv({"set": [["dom.ipc.browser_frames.oop_by_default", true],
+                                       ["media.useAudioChannelAPI", true],
+                                       ["media.useAudioChannelService", true],
+                                       ["media.defaultAudioChannel", "telephony"],
+                                       ["dom.mozBrowserFramesEnabled", true],
+                                       ["network.disable.ipc.security", true]]}, runTest);
+  },
+
+  // Run 2 apps
+  mainApp,
+  newApp,
+];
+
+function runTest() {
+  if (!tests.length) {
+    finish();
+    return;
+  }
+
+  var test = tests.shift();
+  test();
+}
+
+function finish() {
+  SimpleTest.finish();
+}
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("untriaged");
+runTest();
+
+  </script>
+</body>
+</html>
diff --git a/dom/base/nsGkAtomList.h b/dom/base/nsGkAtomList.h
index 30de73cac69..816a4cfadf0 100644
--- a/dom/base/nsGkAtomList.h
+++ b/dom/base/nsGkAtomList.h
@@ -2055,7 +2055,6 @@ GK_ATOM(onwarning, "onwarning")
 GK_ATOM(onstart, "onstart")
 GK_ATOM(onstop, "onstop")
 GK_ATOM(onphoto, "onphoto")
-GK_ATOM(onactivestatechanged, "onactivestatechanged")
 #ifdef MOZ_GAMEPAD
 GK_ATOM(ongamepadbuttondown, "ongamepadbuttondown")
 GK_ATOM(ongamepadbuttonup, "ongamepadbuttonup")
diff --git a/dom/base/nsGlobalWindow.cpp b/dom/base/nsGlobalWindow.cpp
index 25679f0e796..3a76b314b7c 100644
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -3735,10 +3735,39 @@ nsPIDOMWindow::SetAudioVolume(float aVolume)
   return NS_OK;
 }
 
+float
+nsPIDOMWindow::GetAudioGlobalVolume()
+{
+  float globalVolume = 1.0;
+  nsCOMPtr<nsPIDOMWindow> window = this;
+
+  do {
+    if (window->GetAudioMuted()) {
+      return 0;
+    }
+
+    globalVolume *= window->GetAudioVolume();
+
+    nsCOMPtr<nsIDOMWindow> win;
+    window->GetParent(getter_AddRefs(win));
+    if (window == win) {
+      break;
+    }
+
+    window = do_QueryInterface(win);
+
+    // If there is not parent, or we are the toplevel or the volume is
+    // already 0.0, we don't continue.
+  } while (window && window != this && globalVolume);
+
+  return globalVolume;
+}
+
 void
 nsPIDOMWindow::RefreshMediaElements()
 {
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  nsRefPtr<AudioChannelService> service =
+    AudioChannelService::GetOrCreateAudioChannelService();
   service->RefreshAgentsVolume(GetCurrentInnerWindow());
 }
 
diff --git a/dom/base/nsPIDOMWindow.h b/dom/base/nsPIDOMWindow.h
index 3f7b1b220fd..fd4593d580e 100644
--- a/dom/base/nsPIDOMWindow.h
+++ b/dom/base/nsPIDOMWindow.h
@@ -185,6 +185,8 @@ public:
   float GetAudioVolume() const;
   nsresult SetAudioVolume(float aVolume);
 
+  float GetAudioGlobalVolume();
+
   virtual void SetServiceWorkersTestingEnabled(bool aEnabled)
   {
     MOZ_ASSERT(IsOuterWindow());
diff --git a/dom/browser-element/BrowserElementAudioChannel.cpp b/dom/browser-element/BrowserElementAudioChannel.cpp
deleted file mode 100644
index bb540ba1111..00000000000
--- a/dom/browser-element/BrowserElementAudioChannel.cpp
+++ /dev/null
@@ -1,489 +0,0 @@
-/* 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/. */
-
-#include "BrowserElementAudioChannel.h"
-
-#include "mozilla/Services.h"
-#include "mozilla/dom/BrowserElementAudioChannelBinding.h"
-#include "mozilla/dom/DOMRequest.h"
-#include "mozilla/dom/ToJSValue.h"
-#include "AudioChannelService.h"
-#include "nsIBrowserElementAPI.h"
-#include "nsIDocShell.h"
-#include "nsIDOMDOMRequest.h"
-#include "nsIObserverService.h"
-#include "nsISupportsPrimitives.h"
-#include "nsITabParent.h"
-#include "nsPIDOMWindow.h"
-
-namespace {
-
-void
-AssertIsInMainProcess()
-{
-  MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
-}
-
-} // anonymous namespace
-
-namespace mozilla {
-namespace dom {
-
-NS_IMPL_ADDREF_INHERITED(BrowserElementAudioChannel, DOMEventTargetHelper)
-NS_IMPL_RELEASE_INHERITED(BrowserElementAudioChannel, DOMEventTargetHelper)
-
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(BrowserElementAudioChannel)
-  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
-  NS_INTERFACE_MAP_ENTRY(nsIObserver)
-NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
-
-NS_IMPL_CYCLE_COLLECTION_INHERITED(BrowserElementAudioChannel,
-                                   DOMEventTargetHelper,
-                                   mFrameLoader,
-                                   mFrameWindow,
-                                   mTabParent,
-                                   mBrowserElementAPI)
-
-BrowserElementAudioChannel::BrowserElementAudioChannel(
-                                                   nsPIDOMWindow* aWindow,
-                                                   nsIFrameLoader* aFrameLoader,
-                                                   nsIBrowserElementAPI* aAPI,
-                                                   AudioChannel aAudioChannel)
-  : DOMEventTargetHelper(aWindow)
-  , mFrameLoader(aFrameLoader)
-  , mBrowserElementAPI(aAPI)
-  , mAudioChannel(aAudioChannel)
-  , mState(eStateUnknown)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-  MOZ_ASSERT(mFrameLoader);
-
-  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-  if (obs) {
-    nsAutoString name;
-    AudioChannelService::GetAudioChannelString(aAudioChannel, name);
-
-    nsAutoCString topic;
-    topic.Assign("audiochannel-activity-");
-    topic.Append(NS_ConvertUTF16toUTF8(name));
-
-    obs->AddObserver(this, topic.get(), true);
-  }
-}
-
-BrowserElementAudioChannel::~BrowserElementAudioChannel()
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-
-  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-  if (obs) {
-    nsAutoString name;
-    AudioChannelService::GetAudioChannelString(mAudioChannel, name);
-
-    nsAutoCString topic;
-    topic.Assign("audiochannel-activity-");
-    topic.Append(NS_ConvertUTF16toUTF8(name));
-
-    obs->RemoveObserver(this, topic.get());
-  }
-}
-
-nsresult
-BrowserElementAudioChannel::Initialize()
-{
-  nsCOMPtr<nsIDocShell> docShell;
-  nsresult rv = mFrameLoader->GetDocShell(getter_AddRefs(docShell));
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
-  }
-
-  if (docShell) {
-    nsCOMPtr<nsPIDOMWindow> window = docShell->GetWindow();
-    if (!window) {
-      return NS_ERROR_FAILURE;
-    }
-
-    nsCOMPtr<nsIDOMWindow> topWindow;
-    window->GetScriptableTop(getter_AddRefs(topWindow));
-
-    mFrameWindow = do_QueryInterface(topWindow);
-    mFrameWindow = mFrameWindow->GetOuterWindow();
-    return NS_OK;
-  }
-
-  rv = mFrameLoader->GetTabParent(getter_AddRefs(mTabParent));
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
-  }
-
-  MOZ_ASSERT(mTabParent);
-  return NS_OK;
-}
-
-JSObject*
-BrowserElementAudioChannel::WrapObject(JSContext *aCx,
-                                       JS::Handle<JSObject*> aGivenProto)
-{
-  return BrowserElementAudioChannelBinding::Wrap(aCx, this, aGivenProto);
-}
-
-AudioChannel
-BrowserElementAudioChannel::Name() const
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-
-  return mAudioChannel;
-}
-
-namespace {
-
-class BaseRunnable : public nsRunnable
-{
-protected:
-  nsCOMPtr<nsPIDOMWindow> mParentWindow;
-  nsCOMPtr<nsPIDOMWindow> mFrameWindow;
-  nsRefPtr<DOMRequest> mRequest;
-  AudioChannel mAudioChannel;
-
-  virtual void DoWork(AudioChannelService* aService,
-                      JSContext* aCx) = 0;
-
-public:
-  BaseRunnable(nsPIDOMWindow* aParentWindow, nsPIDOMWindow* aFrameWindow,
-               DOMRequest* aRequest, AudioChannel aAudioChannel)
-    : mParentWindow(aParentWindow)
-    , mFrameWindow(aFrameWindow)
-    , mRequest(aRequest)
-    , mAudioChannel(aAudioChannel)
-  {}
-
-  NS_IMETHODIMP Run() override
-  {
-    nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
-    MOZ_ASSERT(service);
-
-    AutoJSAPI jsapi;
-    if (!jsapi.Init(mParentWindow)) {
-      mRequest->FireError(NS_ERROR_FAILURE);
-      return NS_OK;
-    }
-
-    DoWork(service, jsapi.cx());
-    return NS_OK;
-  }
-};
-
-class GetVolumeRunnable final : public BaseRunnable
-{
-public:
-  GetVolumeRunnable(nsPIDOMWindow* aParentWindow, nsPIDOMWindow* aFrameWindow,
-                    DOMRequest* aRequest, AudioChannel aAudioChannel)
-    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
-  {}
-
-protected:
-  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
-  {
-    float volume = aService->GetAudioChannelVolume(mFrameWindow, mAudioChannel);
-
-    JS::Rooted<JS::Value> value(aCx);
-    if (!ToJSValue(aCx, volume, &value)) {
-      mRequest->FireError(NS_ERROR_FAILURE);
-      return;
-    }
-
-    mRequest->FireSuccess(value);
-  }
-};
-
-class GetMutedRunnable final : public BaseRunnable
-{
-public:
-  GetMutedRunnable(nsPIDOMWindow* aParentWindow, nsPIDOMWindow* aFrameWindow,
-                   DOMRequest* aRequest, AudioChannel aAudioChannel)
-    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
-  {}
-
-protected:
-  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
-  {
-    bool muted = aService->GetAudioChannelMuted(mFrameWindow, mAudioChannel);
-
-    JS::Rooted<JS::Value> value(aCx);
-    if (!ToJSValue(aCx, muted, &value)) {
-      mRequest->FireError(NS_ERROR_FAILURE);
-      return;
-    }
-
-    mRequest->FireSuccess(value);
-  }
-};
-
-class IsActiveRunnable final : public BaseRunnable
-{
-  bool mActive;
-  bool mValueKnown;
-
-public:
-  IsActiveRunnable(nsPIDOMWindow* aParentWindow, nsPIDOMWindow* aFrameWindow,
-                   DOMRequest* aRequest, AudioChannel aAudioChannel,
-                   bool aActive)
-    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
-    , mActive(aActive)
-    , mValueKnown(true)
-  {}
-
-  IsActiveRunnable(nsPIDOMWindow* aParentWindow, nsPIDOMWindow* aFrameWindow,
-                   DOMRequest* aRequest, AudioChannel aAudioChannel)
-    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
-    , mActive(true)
-    , mValueKnown(false)
-  {}
-
-protected:
-  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
-  {
-    if (!mValueKnown) {
-      mActive = aService->IsAudioChannelActive(mFrameWindow, mAudioChannel);
-    }
-
-    JS::Rooted<JS::Value> value(aCx);
-    if (!ToJSValue(aCx, mActive, &value)) {
-      mRequest->FireError(NS_ERROR_FAILURE);
-      return;
-    }
-
-    mRequest->FireSuccess(value);
-  }
-};
-
-class FireSuccessRunnable final : public BaseRunnable
-{
-public:
-  FireSuccessRunnable(nsPIDOMWindow* aParentWindow, nsPIDOMWindow* aFrameWindow,
-                      DOMRequest* aRequest, AudioChannel aAudioChannel)
-    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
-  {}
-
-protected:
-  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
-  {
-    JS::Rooted<JS::Value> value(aCx);
-    mRequest->FireSuccess(value);
-  }
-};
-
-} // anonymous namespace
-
-already_AddRefed<dom::DOMRequest>
-BrowserElementAudioChannel::GetVolume(ErrorResult& aRv)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-
-  if (!mFrameWindow) {
-    nsCOMPtr<nsIDOMDOMRequest> request;
-    aRv = mBrowserElementAPI->GetAudioChannelVolume((uint32_t)mAudioChannel,
-                                                    getter_AddRefs(request));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return nullptr;
-    }
-
-    return request.forget().downcast<DOMRequest>();
-  }
-
-  nsRefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
-
-  nsCOMPtr<nsIRunnable> runnable =
-    new GetVolumeRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel);
-  NS_DispatchToMainThread(runnable);
-
-  return domRequest.forget();
-}
-
-already_AddRefed<dom::DOMRequest>
-BrowserElementAudioChannel::SetVolume(float aVolume, ErrorResult& aRv)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-
-  if (!mFrameWindow) {
-    nsCOMPtr<nsIDOMDOMRequest> request;
-    aRv = mBrowserElementAPI->SetAudioChannelVolume((uint32_t)mAudioChannel,
-                                                    aVolume,
-                                                    getter_AddRefs(request));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return nullptr;
-    }
-
-    return request.forget().downcast<DOMRequest>();
-  }
-
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
-  MOZ_ASSERT(service);
-
-  service->SetAudioChannelVolume(mFrameWindow, mAudioChannel, aVolume);
-
-  nsRefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
-  nsCOMPtr<nsIRunnable> runnable = new FireSuccessRunnable(GetOwner(),
-                                                           mFrameWindow,
-                                                           domRequest,
-                                                           mAudioChannel);
-  NS_DispatchToMainThread(runnable);
-
-  return domRequest.forget();
-}
-
-already_AddRefed<dom::DOMRequest>
-BrowserElementAudioChannel::GetMuted(ErrorResult& aRv)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-
-  if (!mFrameWindow) {
-    nsCOMPtr<nsIDOMDOMRequest> request;
-    aRv = mBrowserElementAPI->GetAudioChannelMuted((uint32_t)mAudioChannel,
-                                                   getter_AddRefs(request));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return nullptr;
-    }
-
-    return request.forget().downcast<DOMRequest>();
-  }
-
-  nsRefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
-
-  nsCOMPtr<nsIRunnable> runnable =
-    new GetMutedRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel);
-  NS_DispatchToMainThread(runnable);
-
-  return domRequest.forget();
-}
-
-already_AddRefed<dom::DOMRequest>
-BrowserElementAudioChannel::SetMuted(bool aMuted, ErrorResult& aRv)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-
-  if (!mFrameWindow) {
-    nsCOMPtr<nsIDOMDOMRequest> request;
-    aRv = mBrowserElementAPI->SetAudioChannelMuted((uint32_t)mAudioChannel,
-                                                   aMuted,
-                                                   getter_AddRefs(request));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return nullptr;
-    }
-
-    return request.forget().downcast<DOMRequest>();
-  }
-
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
-  MOZ_ASSERT(service);
-
-  service->SetAudioChannelMuted(mFrameWindow, mAudioChannel, aMuted);
-
-  nsRefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
-  nsCOMPtr<nsIRunnable> runnable = new FireSuccessRunnable(GetOwner(),
-                                                           mFrameWindow,
-                                                           domRequest,
-                                                           mAudioChannel);
-  NS_DispatchToMainThread(runnable);
-
-  return domRequest.forget();
-}
-
-already_AddRefed<dom::DOMRequest>
-BrowserElementAudioChannel::IsActive(ErrorResult& aRv)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  AssertIsInMainProcess();
-
-  if (mState != eStateUnknown) {
-    nsRefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
-
-    nsCOMPtr<nsIRunnable> runnable =
-      new IsActiveRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel,
-                           mState == eStateActive);
-    NS_DispatchToMainThread(runnable);
-
-    return domRequest.forget();
-  }
-
-  if (!mFrameWindow) {
-    nsCOMPtr<nsIDOMDOMRequest> request;
-    aRv = mBrowserElementAPI->IsAudioChannelActive((uint32_t)mAudioChannel,
-                                                   getter_AddRefs(request));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return nullptr;
-    }
-
-    return request.forget().downcast<DOMRequest>();
-  }
-
-  nsRefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
-
-  nsCOMPtr<nsIRunnable> runnable =
-    new IsActiveRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel);
-  NS_DispatchToMainThread(runnable);
-
-  return domRequest.forget();
-}
-
-NS_IMETHODIMP
-BrowserElementAudioChannel::Observe(nsISupports* aSubject, const char* aTopic,
-                                    const char16_t* aData)
-{
-  nsAutoString name;
-  AudioChannelService::GetAudioChannelString(mAudioChannel, name);
-
-  nsAutoCString topic;
-  topic.Assign("audiochannel-activity-");
-  topic.Append(NS_ConvertUTF16toUTF8(name));
-
-  if (strcmp(topic.get(), aTopic)) {
-    return NS_OK;
-  }
-
-  // Message received from the child.
-  if (!mFrameWindow) {
-    if (mTabParent == aSubject) {
-      ProcessStateChanged(aData);
-    }
-
-    return NS_OK;
-  }
-
-  nsCOMPtr<nsISupportsPRUint64> wrapper = do_QueryInterface(aSubject);
-  if (NS_WARN_IF(!wrapper)) {
-    return NS_ERROR_FAILURE;
-  }
-
-  uint64_t windowID;
-  nsresult rv = wrapper->GetData(&windowID);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
-  }
-
-  if (windowID != mFrameWindow->WindowID()) {
-    return NS_OK;
-  }
-
-  ProcessStateChanged(aData);
-  return NS_OK;
-}
-
-void
-BrowserElementAudioChannel::ProcessStateChanged(const char16_t* aData)
-{
-  nsAutoString value(aData);
-  mState = value.EqualsASCII("active") ? eStateActive : eStateInactive;
-  DispatchTrustedEvent(NS_LITERAL_STRING("activestatechanged"));
-}
-
-} // dom namespace
-} // mozilla namespace
diff --git a/dom/browser-element/BrowserElementAudioChannel.h b/dom/browser-element/BrowserElementAudioChannel.h
deleted file mode 100644
index af990caa8a5..00000000000
--- a/dom/browser-element/BrowserElementAudioChannel.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/* 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/. */
-
-#ifndef mozilla_dom_BrowserElementAudioChannels_h
-#define mozilla_dom_BrowserElementAudioChannels_h
-
-#include "mozilla/dom/AudioChannelBinding.h"
-#include "mozilla/dom/BindingDeclarations.h"
-#include "mozilla/DOMEventTargetHelper.h"
-#include "mozilla/ErrorResult.h"
-#include "nsCycleCollectionParticipant.h"
-#include "nsIObserver.h"
-#include "nsIFrameLoader.h"
-#include "nsWeakReference.h"
-#include "nsWrapperCache.h"
-
-class nsIBrowserElementAPI;
-class nsITabParent;
-class nsPIDOMWindow;
-
-namespace mozilla {
-namespace dom {
-
-class DOMRequest;
-
-class BrowserElementAudioChannel final : public DOMEventTargetHelper
-                                       , public nsSupportsWeakReference
-                                       , public nsIObserver
-{
-public:
-  NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_NSIOBSERVER
-
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(BrowserElementAudioChannel,
-                                           DOMEventTargetHelper)
-
-  BrowserElementAudioChannel(nsPIDOMWindow* aWindow,
-                             nsIFrameLoader* aFrameLoader,
-                             nsIBrowserElementAPI* aAPI,
-                             AudioChannel aAudioChannel);
-
-  nsresult Initialize();
-
-  // WebIDL methods
-
-  virtual JSObject* WrapObject(JSContext *aCx,
-                               JS::Handle<JSObject*> aGivenProto) override;
-
-  AudioChannel Name() const;
-
-  already_AddRefed<dom::DOMRequest> GetVolume(ErrorResult& aRv);
-  already_AddRefed<dom::DOMRequest> SetVolume(float aVolume, ErrorResult& aRv);
-
-  already_AddRefed<dom::DOMRequest> GetMuted(ErrorResult& aRv);
-  already_AddRefed<dom::DOMRequest> SetMuted(bool aMuted, ErrorResult& aRv);
-
-  already_AddRefed<dom::DOMRequest> IsActive(ErrorResult& aRv);
-
-  IMPL_EVENT_HANDLER(activestatechanged);
-
-private:
-  ~BrowserElementAudioChannel();
-
-  void ProcessStateChanged(const char16_t* aData);
-
-  nsCOMPtr<nsIFrameLoader> mFrameLoader;
-  nsCOMPtr<nsIBrowserElementAPI> mBrowserElementAPI;
-  nsCOMPtr<nsITabParent> mTabParent;
-  nsCOMPtr<nsPIDOMWindow> mFrameWindow;
-  AudioChannel mAudioChannel;
-
-  enum {
-    eStateActive,
-    eStateInactive,
-    eStateUnknown
-  } mState;
-};
-
-} // dom namespace
-} // mozilla namespace
-
-#endif // mozilla_dom_BrowserElementAudioChannels_h
diff --git a/dom/browser-element/BrowserElementChildPreload.js b/dom/browser-element/BrowserElementChildPreload.js
index 457f882496a..147a4af91e7 100644
--- a/dom/browser-element/BrowserElementChildPreload.js
+++ b/dom/browser-element/BrowserElementChildPreload.js
@@ -13,10 +13,6 @@ Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/BrowserElementPromptService.jsm");
 
-XPCOMUtils.defineLazyServiceGetter(this, "acs",
-                                   "@mozilla.org/audiochannel/service;1",
-                                   "nsIAudioChannelService");
-
 let kLongestReturnedString = 128;
 
 function debug(msg) {
@@ -238,11 +234,6 @@ BrowserElementChild.prototype = {
       "find-all": this._recvFindAll.bind(this),
       "find-next": this._recvFindNext.bind(this),
       "clear-match": this._recvClearMatch.bind(this),
-      "get-audio-channel-volume": this._recvGetAudioChannelVolume,
-      "set-audio-channel-volume": this._recvSetAudioChannelVolume,
-      "get-audio-channel-muted": this._recvGetAudioChannelMuted,
-      "set-audio-channel-muted": this._recvSetAudioChannelMuted,
-      "get-is-audio-channel-active": this._recvIsAudioChannelActive
     }
 
     addMessageListener("browser-element-api:call", function(aMessage) {
@@ -1255,55 +1246,6 @@ BrowserElementChild.prototype = {
     }
   },
 
-  _recvGetAudioChannelVolume: function(data) {
-    debug("Received getAudioChannelVolume message: (" + data.json.id + ")");
-
-    let volume = acs.getAudioChannelVolume(content,
-                                           data.json.args.audioChannel);
-    sendAsyncMsg('got-audio-channel-volume', {
-      id: data.json.id, successRv: volume
-    });
-  },
-
-  _recvSetAudioChannelVolume: function(data) {
-    debug("Received setAudioChannelVolume message: (" + data.json.id + ")");
-
-    acs.setAudioChannelVolume(content,
-                              data.json.args.audioChannel,
-                              data.json.args.volume);
-    sendAsyncMsg('got-set-audio-channel-volume', {
-      id: data.json.id, successRv: true
-    });
-  },
-
-  _recvGetAudioChannelMuted: function(data) {
-    debug("Received getAudioChannelMuted message: (" + data.json.id + ")");
-
-    let muted = acs.getAudioChannelMuted(content, data.json.args.audioChannel);
-    sendAsyncMsg('got-audio-channel-muted', {
-      id: data.json.id, successRv: muted
-    });
-  },
-
-  _recvSetAudioChannelMuted: function(data) {
-    debug("Received setAudioChannelMuted message: (" + data.json.id + ")");
-
-    acs.setAudioChannelMuted(content, data.json.args.audioChannel,
-                             data.json.args.muted);
-    sendAsyncMsg('got-set-audio-channel-muted', {
-      id: data.json.id, successRv: true
-    });
-  },
-
-  _recvIsAudioChannelActive: function(data) {
-    debug("Received isAudioChannelActive message: (" + data.json.id + ")");
-
-    let active = acs.isAudioChannelActive(content, data.json.args.audioChannel);
-    sendAsyncMsg('got-is-audio-channel-active', {
-      id: data.json.id, successRv: active
-    });
-  },
-
   _initFinder: function() {
     if (!this._finder) {
       try {
diff --git a/dom/browser-element/BrowserElementParent.cpp b/dom/browser-element/BrowserElementParent.cpp
index d1094c12198..8c77ba46bc2 100644
--- a/dom/browser-element/BrowserElementParent.cpp
+++ b/dom/browser-element/BrowserElementParent.cpp
@@ -15,7 +15,6 @@
 #endif
 
 #include "BrowserElementParent.h"
-#include "BrowserElementAudioChannel.h"
 #include "mozilla/EventDispatcher.h"
 #include "mozilla/dom/HTMLIFrameElement.h"
 #include "mozilla/dom/ToJSValue.h"
diff --git a/dom/browser-element/BrowserElementParent.js b/dom/browser-element/BrowserElementParent.js
index 44a0c3e5a0e..4dfa4a9ab92 100644
--- a/dom/browser-element/BrowserElementParent.js
+++ b/dom/browser-element/BrowserElementParent.js
@@ -206,12 +206,7 @@ BrowserElementParent.prototype = {
       "selectionstatechanged": this._handleSelectionStateChanged,
       "scrollviewchange": this._handleScrollViewChange,
       "caretstatechanged": this._handleCaretStateChanged,
-      "findchange": this._handleFindChange,
-      "got-audio-channel-volume": this._gotDOMRequestResult,
-      "got-set-audio-channel-volume": this._gotDOMRequestResult,
-      "got-audio-channel-muted": this._gotDOMRequestResult,
-      "got-set-audio-channel-muted": this._gotDOMRequestResult,
-      "got-is-audio-channel-active": this._gotDOMRequestResult
+      "findchange": this._handleFindChange
     };
 
     let mmSecuritySensitiveCalls = {
@@ -978,33 +973,6 @@ BrowserElementParent.prototype = {
     }
   },
 
-  getAudioChannelVolume: function(aAudioChannel) {
-    return this._sendDOMRequest('get-audio-channel-volume',
-                                {audioChannel: aAudioChannel});
-  },
-
-  setAudioChannelVolume: function(aAudioChannel, aVolume) {
-    return this._sendDOMRequest('set-audio-channel-volume',
-                                {audioChannel: aAudioChannel,
-                                 volume: aVolume});
-  },
-
-  getAudioChannelMuted: function(aAudioChannel) {
-    return this._sendDOMRequest('get-audio-channel-muted',
-                                {audioChannel: aAudioChannel});
-  },
-
-  setAudioChannelMuted: function(aAudioChannel, aMuted) {
-    return this._sendDOMRequest('set-audio-channel-muted',
-                                {audioChannel: aAudioChannel,
-                                 muted: aMuted});
-  },
-
-  isAudioChannelActive: function(aAudioChannel) {
-    return this._sendDOMRequest('get-is-audio-channel-active',
-                                {audioChannel: aAudioChannel});
-  },
-
   /**
    * Called when the visibility of the window which owns this iframe changes.
    */
diff --git a/dom/browser-element/mochitest/browserElement_AudioChannel.js b/dom/browser-element/mochitest/browserElement_AudioChannel.js
deleted file mode 100644
index f61ff70bf81..00000000000
--- a/dom/browser-element/mochitest/browserElement_AudioChannel.js
+++ /dev/null
@@ -1,153 +0,0 @@
-/* Any copyright is dedicated to the public domain.
-   http://creativecommons.org/publicdomain/zero/1.0/ */
-
-// Bug 1113086 - tests for AudioChannel API into BrowserElement
-
-"use strict";
-
-SimpleTest.waitForExplicitFinish();
-browserElementTestHelpers.setEnabledPref(true);
-browserElementTestHelpers.addPermission();
-
-SpecialPowers.setBoolPref("dom.testing.browserElementAudioChannel.noapp", true);
-SpecialPowers.setBoolPref("media.useAudioChannelService", true);
-
-function noaudio() {
-  var iframe = document.createElement('iframe');
-  iframe.setAttribute('mozbrowser', 'true');
-  iframe.setAttribute('mozapp', 'http://example.org/manifest.webapp');
-  iframe.src = 'http://example.org/tests/dom/browser-element/mochitest/file_empty.html';
-
-  function noaudio_loadend() {
-    ok("allowedAudioChannels" in iframe, "allowedAudioChannels exist");
-    var channels = iframe.allowedAudioChannels;
-    is(channels.length, 1, "1 audio channel by default");
-
-    var ac = channels[0];
-
-    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
-    ok("getVolume" in ac, "ac.getVolume exists");
-    ok("setVolume" in ac, "ac.setVolume exists");
-    ok("getMuted" in ac, "ac.getMuted exists");
-    ok("setMuted" in ac, "ac.setMuted exists");
-    ok("isActive" in ac, "ac.isActive exists");
-
-    new Promise(function(r, rr) {
-      var req = ac.getVolume();
-      ok(req instanceof DOMRequest, "This is a domRequest.");
-      req.onsuccess = function(e) {
-        is(e.target.result, 1.0, "The default volume should be 1.0");
-        r();
-      }
-    })
-
-    .then(function() {
-      return new Promise(function(r, rr) {
-        ac.getMuted().onsuccess = function(e) {
-          is(e.target.result, false, "The default muted value should be false");
-          r();
-        }
-      });
-    })
-
-    .then(function() {
-      return new Promise(function(r, rr) {
-        ac.setVolume(0.8).onsuccess = function() { r(); }
-      });
-    })
-
-    .then(function() {
-      return new Promise(function(r, rr) {
-        ac.getVolume().onsuccess = function(e) {
-          // the actual value is 0.800000011920929..
-          ok(Math.abs(0.8 - e.target.result) < 0.01, "The new volume should be 0.8: " + e.target.result);
-          r();
-        }
-      });
-    })
-
-    .then(function() {
-      return new Promise(function(r, rr) {
-        ac.setVolume(1.0).onsuccess = function() { r(); }
-      });
-    })
-
-    .then(function() {
-      return new Promise(function(r, rr) {
-        ac.setMuted(true).onsuccess = function() { r(); }
-      });
-    })
-
-    .then(function() {
-      return new Promise(function(r, rr) {
-        ac.getMuted().onsuccess = function(e) {
-          is(e.target.result, true, "The new muted value should be true");
-          r();
-        }
-      });
-    })
-
-    .then(function() {
-      return new Promise(function(r, rr) {
-        ac.isActive().onsuccess = function(e) {
-          is(e.target.result, false, "ac.isActive is false: no audio element active.");
-          r();
-        }
-      });
-    })
-
-    .then(runTests);
-  }
-
-  iframe.addEventListener('mozbrowserloadend', noaudio_loadend);
-  document.body.appendChild(iframe);
-}
-
-function audio() {
-  var iframe = document.createElement('iframe');
-  iframe.setAttribute('mozbrowser', 'true');
-  iframe.setAttribute('mozapp', 'http://example.org/manifest.webapp');
-  iframe.src = 'http://example.org/tests/dom/browser-element/mochitest/iframe_file_audio.html';
-
-  function audio_loadend() {
-    ok("allowedAudioChannels" in iframe, "allowedAudioChannels exist");
-    var channels = iframe.allowedAudioChannels;
-    is(channels.length, 1, "1 audio channel by default");
-
-    var ac = channels[0];
-
-    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
-    ok("getVolume" in ac, "ac.getVolume exists");
-    ok("setVolume" in ac, "ac.setVolume exists");
-    ok("getMuted" in ac, "ac.getMuted exists");
-    ok("setMuted" in ac, "ac.setMuted exists");
-    ok("isActive" in ac, "ac.isActive exists");
-
-    ac.onactivestatechanged = function() {
-      ok("activestatechanged event received.");
-      ac.onactivestatechanged = null;
-      runTests();
-    }
-  }
-
-  iframe.addEventListener('mozbrowserloadend', audio_loadend);
-  document.body.appendChild(iframe);
-}
-
-var tests = [ noaudio, audio ];
-
-function runTests() {
-  if (tests.length == 0) {
-    SimpleTest.finish();
-    return;
-  }
-
-  var test = tests.shift();
-  test();
-}
-
-
-addEventListener('load', function() {
-  SimpleTest.executeSoon(runTests);
-});
-
diff --git a/dom/browser-element/mochitest/file_audio.html b/dom/browser-element/mochitest/file_audio.html
deleted file mode 100644
index 38ea1c41f3d..00000000000
--- a/dom/browser-element/mochitest/file_audio.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<html>
-<body>
-<audio src="http://mochi.test:8888/tests/dom/browser-element/mochitest/audio.ogg" id="audio" />
-<script>
-var audio = document.getElementById('audio');
-audio.play();
-audio.onended = function() {
-  setTimeout(function() {
-    audio.play();
-  }, 0);
-}
-</script>
-
-</body>
-</html>
diff --git a/dom/browser-element/mochitest/iframe_file_audio.html b/dom/browser-element/mochitest/iframe_file_audio.html
deleted file mode 100644
index 605ce2870c5..00000000000
--- a/dom/browser-element/mochitest/iframe_file_audio.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<html>
-<body>
-<iframe src="file_audio.html"></iframe>
-</body>
-</html>
diff --git a/dom/browser-element/mochitest/mochitest-oop.ini b/dom/browser-element/mochitest/mochitest-oop.ini
index cd86593be0b..6c184983278 100644
--- a/dom/browser-element/mochitest/mochitest-oop.ini
+++ b/dom/browser-element/mochitest/mochitest-oop.ini
@@ -109,4 +109,3 @@ disabled = bug 924771
 [test_browserElement_oop_ExposableURI.html]
 disabled = bug 924771
 [test_browserElement_oop_GetContentDimensions.html]
-[test_browserElement_oop_AudioChannel.html]
diff --git a/dom/browser-element/mochitest/mochitest.ini b/dom/browser-element/mochitest/mochitest.ini
index c28e0c977b3..595c3f356ee 100644
--- a/dom/browser-element/mochitest/mochitest.ini
+++ b/dom/browser-element/mochitest/mochitest.ini
@@ -75,7 +75,6 @@ support-files =
   browserElement_XFrameOptionsSameOrigin.js
   browserElement_XFrameOptionsSameOrigin.js
   browserElement_GetContentDimensions.js
-  browserElement_AudioChannel.js
   file_browserElement_AlertInFrame.html
   file_browserElement_AlertInFrame_Inner.html
   file_browserElement_AllowEmbedAppsInNestedOOIframe.html
@@ -123,8 +122,6 @@ support-files =
   file_inputmethod.html
   file_post_request.html
   file_wyciwyg.html
-  file_audio.html
-  iframe_file_audio.html
 
 # Note: browserElementTestHelpers.js looks at the test's filename to determine
 # whether the test should be OOP.  "_oop_" signals OOP, "_inproc_" signals in
@@ -226,4 +223,3 @@ skip-if = (toolkit == 'android' && processor == 'x86') #x86 only bug 936226
 [test_browserElement_inproc_Reload.html]
 disabled = bug 774100
 [test_browserElement_inproc_GetContentDimensions.html]
-[test_browserElement_inproc_AudioChannel.html]
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel.html b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel.html
deleted file mode 100644
index 34909e904a9..00000000000
--- a/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test of browser element audioChannel.</title>
-  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
-</head>
-<body>
-<script type="application/javascript;version=1.7" src="browserElement_AudioChannel.js">
-</script>
-</body>
-</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel.html b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel.html
deleted file mode 100644
index 34909e904a9..00000000000
--- a/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test of browser element audioChannel.</title>
-  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
-</head>
-<body>
-<script type="application/javascript;version=1.7" src="browserElement_AudioChannel.js">
-</script>
-</body>
-</html>
diff --git a/dom/browser-element/moz.build b/dom/browser-element/moz.build
index 309b7d63e2e..3a28fc1ffaa 100644
--- a/dom/browser-element/moz.build
+++ b/dom/browser-element/moz.build
@@ -8,12 +8,7 @@ EXPORTS.mozilla += [
     'BrowserElementParent.h',
 ]
 
-EXPORTS.mozilla.dom += [
-    'BrowserElementAudioChannel.h',
-]
-
 SOURCES += [
-    'BrowserElementAudioChannel.cpp',
     'BrowserElementParent.cpp',
 ]
 
diff --git a/dom/browser-element/nsIBrowserElementAPI.idl b/dom/browser-element/nsIBrowserElementAPI.idl
index 04a68c88794..95a9ae940ef 100644
--- a/dom/browser-element/nsIBrowserElementAPI.idl
+++ b/dom/browser-element/nsIBrowserElementAPI.idl
@@ -26,7 +26,7 @@ interface nsIBrowserElementNextPaintListener : nsISupports
  * Interface to the BrowserElementParent implementation. All methods
  * but setFrameLoader throw when the remote process is dead.
  */
-[scriptable, uuid(daa264b2-54df-4fc7-89b7-c9d02167c5d4)]
+[scriptable, uuid(8ecb598c-f886-11e4-9915-778f934fbf93)]
 interface nsIBrowserElementAPI : nsISupports
 {
   const long FIND_CASE_SENSITIVE = 0;
@@ -82,13 +82,5 @@ interface nsIBrowserElementAPI : nsISupports
 
   nsIDOMDOMRequest setInputMethodActive(in boolean isActive);
 
-  nsIDOMDOMRequest getAudioChannelVolume(in uint32_t audioChannel);
-  nsIDOMDOMRequest setAudioChannelVolume(in uint32_t audioChannel, in float volume);
-
-  nsIDOMDOMRequest getAudioChannelMuted(in uint32_t audioChannel);
-  nsIDOMDOMRequest setAudioChannelMuted(in uint32_t audioChannel, in bool muted);
-
-  nsIDOMDOMRequest isAudioChannelActive(in uint32_t audioChannel);
-
   void setNFCFocus(in boolean isFocus);
 };
diff --git a/dom/camera/DOMCameraControl.cpp b/dom/camera/DOMCameraControl.cpp
index 010c321198a..9253777f71b 100755
--- a/dom/camera/DOMCameraControl.cpp
+++ b/dom/camera/DOMCameraControl.cpp
@@ -1135,12 +1135,8 @@ nsDOMCameraControl::NotifyRecordingStatusChange(const nsString& aMsg)
     // Camera app will stop recording when it falls to the background, so no callback is necessary.
     mAudioChannelAgent->Init(mWindow, (int32_t)AudioChannel::Content, nullptr);
     // Video recording doesn't output any sound, so it's not necessary to check canPlay.
-    float volume = 0.0;
-    bool muted = true;
-    rv = mAudioChannelAgent->StartPlaying(&volume, &muted);
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return rv;
-    }
+    int32_t canPlay;
+    mAudioChannelAgent->StartPlaying(&canPlay);
   }
 #endif
   return rv;
diff --git a/dom/fmradio/FMRadio.cpp b/dom/fmradio/FMRadio.cpp
index 058263c631e..0ecb82dea82 100644
--- a/dom/fmradio/FMRadio.cpp
+++ b/dom/fmradio/FMRadio.cpp
@@ -135,6 +135,13 @@ FMRadio::Init(nsPIDOMWindow *aWindow)
     RegisterSwitchObserver(SWITCH_HEADPHONES, this);
   }
 
+  nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(GetOwner());
+  NS_ENSURE_TRUE_VOID(target);
+  target->AddSystemEventListener(NS_LITERAL_STRING("visibilitychange"), this,
+                                 /* useCapture = */ true,
+                                 /* wantsUntrusted = */ false);
+
+
   // All of the codes below are for AudioChannel. We can directly return here
   // if preferences doesn't enable AudioChannelService.
   NS_ENSURE_TRUE_VOID(Preferences::GetBool("media.useAudioChannelService"));
@@ -148,6 +155,13 @@ FMRadio::Init(nsPIDOMWindow *aWindow)
     nsIAudioChannelAgent::AUDIO_AGENT_CHANNEL_CONTENT,
     this);
 
+  nsCOMPtr<nsIDocShell> docshell = do_GetInterface(GetOwner());
+  NS_ENSURE_TRUE_VOID(docshell);
+
+  bool isActive = false;
+  docshell->GetIsActive(&isActive);
+  audioChannelAgent->SetVisibilityState(isActive);
+
   // Once all necessary resources are got successfully, we just enabled
   // mAudioChannelAgent.
   mAudioChannelAgent = audioChannelAgent;
@@ -162,6 +176,11 @@ FMRadio::Shutdown()
     UnregisterSwitchObserver(SWITCH_HEADPHONES, this);
   }
 
+  nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(GetOwner());
+  NS_ENSURE_TRUE_VOID(target);
+  target->RemoveSystemEventListener(NS_LITERAL_STRING("visibilitychange"), this,
+                                    /* useCapture = */ true);
+
   mIsShutdown = true;
 }
 
@@ -450,30 +469,61 @@ FMRadio::DisableRDS()
   return r.forget();
 }
 
+NS_IMETHODIMP
+FMRadio::HandleEvent(nsIDOMEvent* aEvent)
+{
+  nsAutoString type;
+  aEvent->GetType(type);
+
+  if (!type.EqualsLiteral("visibilitychange")) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDocShell> docshell = do_GetInterface(GetOwner());
+  NS_ENSURE_TRUE(docshell, NS_ERROR_FAILURE);
+
+  bool isActive = false;
+  docshell->GetIsActive(&isActive);
+
+  mAudioChannelAgent->SetVisibilityState(isActive);
+  return NS_OK;
+}
+
 void
 FMRadio::EnableAudioChannelAgent()
 {
   NS_ENSURE_TRUE_VOID(mAudioChannelAgent);
 
-  float volume = 0.0;
-  bool muted = true;
-  mAudioChannelAgent->StartPlaying(&volume, &muted);
-  WindowVolumeChanged(volume, muted);
+  int32_t playingState = 0;
+  mAudioChannelAgent->StartPlaying(&playingState);
+  SetCanPlay(playingState == AudioChannelState::AUDIO_CHANNEL_STATE_NORMAL);
 
   mAudioChannelAgentEnabled = true;
 }
 
 NS_IMETHODIMP
-FMRadio::WindowVolumeChanged(float aVolume, bool aMuted)
+FMRadio::CanPlayChanged(int32_t aCanPlay)
 {
-  IFMRadioService::Singleton()->EnableAudio(!aMuted);
-  // TODO: what about the volume?
+  SetCanPlay(!(aCanPlay == AudioChannelState::AUDIO_CHANNEL_STATE_MUTED));
   return NS_OK;
 }
 
+NS_IMETHODIMP
+FMRadio::WindowVolumeChanged()
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+void
+FMRadio::SetCanPlay(bool aCanPlay)
+{
+  IFMRadioService::Singleton()->EnableAudio(aCanPlay);
+}
+
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(FMRadio)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
   NS_INTERFACE_MAP_ENTRY(nsIAudioChannelAgentCallback)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 
 NS_IMPL_ADDREF_INHERITED(FMRadio, DOMEventTargetHelper)
diff --git a/dom/fmradio/FMRadio.h b/dom/fmradio/FMRadio.h
index e59d0005206..a921be138bb 100644
--- a/dom/fmradio/FMRadio.h
+++ b/dom/fmradio/FMRadio.h
@@ -25,6 +25,7 @@ class FMRadio final : public DOMEventTargetHelper
                     , public FMRadioEventObserver
                     , public nsSupportsWeakReference
                     , public nsIAudioChannelAgentCallback
+                    , public nsIDOMEventListener
 
 {
   friend class FMRadioRequest;
@@ -108,9 +109,13 @@ public:
   IMPL_EVENT_HANDLER(rtchange);
   IMPL_EVENT_HANDLER(newrdsgroup);
 
+  // nsIDOMEventListener
+  NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent);
+
 private:
   ~FMRadio();
 
+  void SetCanPlay(bool aCanPlay);
   void EnableAudioChannelAgent();
 
   hal::SwitchState mHeadphoneState;
diff --git a/dom/html/HTMLAudioElement.cpp b/dom/html/HTMLAudioElement.cpp
index 591afa71cb9..610bccc5e31 100644
--- a/dom/html/HTMLAudioElement.cpp
+++ b/dom/html/HTMLAudioElement.cpp
@@ -14,6 +14,7 @@
 #include "nsContentUtils.h"
 #include "nsJSUtils.h"
 #include "AudioSampleFormat.h"
+#include "AudioChannelCommon.h"
 #include <algorithm>
 #include "nsComponentManagerUtils.h"
 #include "nsIHttpChannel.h"
diff --git a/dom/html/HTMLMediaElement.cpp b/dom/html/HTMLMediaElement.cpp
index fd70c3bbf37..68bb8a80cbf 100644
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -1831,7 +1831,16 @@ void HTMLMediaElement::SetMutedInternal(uint32_t aMuted)
 
 void HTMLMediaElement::SetVolumeInternal()
 {
-  float effectiveVolume = mMuted ? 0.0f : float(mVolume * mAudioChannelVolume);
+  float effectiveVolume = mMuted ? 0.0f :
+    mAudioChannelFaded ? float(mVolume) * FADED_VOLUME_RATIO : float(mVolume);
+
+  if (mAudioChannelAgent) {
+    float volume;
+    nsresult rv = mAudioChannelAgent->GetWindowVolume(&volume);
+    if (NS_SUCCEEDED(rv)) {
+      effectiveVolume *= volume;
+    }
+  }
 
   if (mDecoder) {
     mDecoder->SetVolume(effectiveVolume);
@@ -2083,7 +2092,7 @@ HTMLMediaElement::HTMLMediaElement(already_AddRefed<mozilla::dom::NodeInfo>& aNo
     mCORSMode(CORS_NONE),
     mIsEncrypted(false),
     mDownloadSuspendedByCache(false, "HTMLMediaElement::mDownloadSuspendedByCache"),
-    mAudioChannelVolume(1.0),
+    mAudioChannelFaded(false),
     mPlayingThroughTheAudioChannel(false),
     mDisableVideo(false),
     mPlayBlockedBecauseHidden(false),
@@ -4034,6 +4043,13 @@ void HTMLMediaElement::NotifyOwnerDocumentActivityChanged()
     mDecoder->NotifyOwnerActivityChanged();
   }
 
+  // SetVisibilityState will update mMuted with MUTED_BY_AUDIO_CHANNEL via the
+  // CanPlayChanged callback.
+  if (UseAudioChannelService() && mPlayingThroughTheAudioChannel &&
+      mAudioChannelAgent) {
+    AutoNoJSAPI nojsapi;
+    mAudioChannelAgent->SetVisibilityState(!ownerDoc->Hidden());
+  }
   bool pauseElement = !IsActive() || (mMuted & MUTED_BY_AUDIO_CHANNEL);
 
   SuspendOrResumeElement(pauseElement, !IsActive());
@@ -4450,24 +4466,26 @@ ImageContainer* HTMLMediaElement::GetImageContainer()
   return container ? container->GetImageContainer() : nullptr;
 }
 
-nsresult HTMLMediaElement::UpdateChannelMuteState(float aVolume, bool aMuted)
+nsresult HTMLMediaElement::UpdateChannelMuteState(AudioChannelState aCanPlay)
 {
   if (!UseAudioChannelService()) {
     return NS_OK;
   }
 
-  if (mAudioChannelVolume != aVolume) {
-    mAudioChannelVolume = aVolume;
+  if ((aCanPlay == AUDIO_CHANNEL_STATE_FADED && !mAudioChannelFaded) ||
+      (aCanPlay != AUDIO_CHANNEL_STATE_FADED && mAudioChannelFaded)) {
+    mAudioChannelFaded = !mAudioChannelFaded;
     SetVolumeInternal();
   }
 
   // We have to mute this channel.
-  if (aMuted && !(mMuted & MUTED_BY_AUDIO_CHANNEL)) {
+  if (aCanPlay == AUDIO_CHANNEL_STATE_MUTED && !(mMuted & MUTED_BY_AUDIO_CHANNEL)) {
     SetMutedInternal(mMuted | MUTED_BY_AUDIO_CHANNEL);
     if (UseAudioChannelAPI()) {
       DispatchAsyncEvent(NS_LITERAL_STRING("mozinterruptbegin"));
     }
-  } else if (!aMuted && (mMuted & MUTED_BY_AUDIO_CHANNEL)) {
+  } else if (aCanPlay != AUDIO_CHANNEL_STATE_MUTED &&
+             (mMuted & MUTED_BY_AUDIO_CHANNEL)) {
     SetMutedInternal(mMuted & ~MUTED_BY_AUDIO_CHANNEL);
     if (UseAudioChannelAPI()) {
       DispatchAsyncEvent(NS_LITERAL_STRING("mozinterruptend"));
@@ -4505,9 +4523,17 @@ void HTMLMediaElement::UpdateAudioChannelPlayingState()
       if (!mAudioChannelAgent) {
         return;
       }
-      mAudioChannelAgent->InitWithWeakCallback(OwnerDoc()->GetWindow(),
-                                               static_cast<int32_t>(mAudioChannel),
-                                               this);
+      // Use a weak ref so the audio channel agent can't leak |this|.
+      if (AudioChannel::Normal == mAudioChannel && IsVideo()) {
+        mAudioChannelAgent->InitWithVideo(OwnerDoc()->GetWindow(),
+                                          static_cast<int32_t>(mAudioChannel),
+                                          this, true);
+      } else {
+        mAudioChannelAgent->InitWithWeakCallback(OwnerDoc()->GetWindow(),
+                                                 static_cast<int32_t>(mAudioChannel),
+                                                 this);
+      }
+      mAudioChannelAgent->SetVisibilityState(!OwnerDoc()->Hidden());
     }
 
     // This is needed to pass nsContentUtils::IsCallerChrome().
@@ -4516,10 +4542,9 @@ void HTMLMediaElement::UpdateAudioChannelPlayingState()
     AutoNoJSAPI nojsapi;
 
     if (mPlayingThroughTheAudioChannel) {
-      float volume = 0.0;
-      bool muted = true;
-      mAudioChannelAgent->StartPlaying(&volume, &muted);
-      WindowVolumeChanged(volume, muted);
+      int32_t canPlay;
+      mAudioChannelAgent->StartPlaying(&canPlay);
+      CanPlayChanged(canPlay);
     } else {
       mAudioChannelAgent->StopPlaying();
       mAudioChannelAgent = nullptr;
@@ -4527,12 +4552,25 @@ void HTMLMediaElement::UpdateAudioChannelPlayingState()
   }
 }
 
-NS_IMETHODIMP HTMLMediaElement::WindowVolumeChanged(float aVolume, bool aMuted)
+/* void canPlayChanged (in boolean canPlay); */
+NS_IMETHODIMP HTMLMediaElement::CanPlayChanged(int32_t canPlay)
 {
+  static_assert(static_cast<AudioChannelState>(
+                nsIAudioChannelAgent::AUDIO_AGENT_STATE_NORMAL) ==
+                AUDIO_CHANNEL_STATE_NORMAL &&
+                static_cast<AudioChannelState>(
+                nsIAudioChannelAgent::AUDIO_AGENT_STATE_MUTED) ==
+                AUDIO_CHANNEL_STATE_MUTED &&
+                static_cast<AudioChannelState>(
+                nsIAudioChannelAgent::AUDIO_AGENT_STATE_FADED) ==
+                AUDIO_CHANNEL_STATE_FADED,
+                "Enum of channel state on nsIAudioChannelAgent.idl should be "
+                "the same with AudioChannelCommon.h");
+
   NS_ENSURE_TRUE(nsContentUtils::IsCallerChrome(), NS_ERROR_NOT_AVAILABLE);
 
-  UpdateChannelMuteState(aVolume, aMuted);
-  mPaused.SetCanPlay(!aMuted);
+  UpdateChannelMuteState(static_cast<AudioChannelState>(canPlay));
+  mPaused.SetCanPlay(canPlay != AUDIO_CHANNEL_STATE_MUTED);
   return NS_OK;
 }
 
@@ -4677,6 +4715,12 @@ HTMLMediaElement::GetTopLevelPrincipal()
 }
 #endif // MOZ_EME
 
+NS_IMETHODIMP HTMLMediaElement::WindowVolumeChanged()
+{
+  SetVolumeInternal();
+  return NS_OK;
+}
+
 AudioTrackList*
 HTMLMediaElement::AudioTracks()
 {
diff --git a/dom/html/HTMLMediaElement.h b/dom/html/HTMLMediaElement.h
index dd0fc969781..e1ee9ccaa91 100644
--- a/dom/html/HTMLMediaElement.h
+++ b/dom/html/HTMLMediaElement.h
@@ -13,6 +13,7 @@
 #include "nsIObserver.h"
 #include "mozilla/CORSMode.h"
 #include "DOMMediaStream.h"
+#include "AudioChannelCommon.h"
 #include "DecoderTraits.h"
 #include "nsIAudioChannelAgent.h"
 #include "mozilla/Attributes.h"
@@ -1007,8 +1008,8 @@ protected:
   // Check the permissions for audiochannel.
   bool CheckAudioChannelPermissions(const nsAString& aType);
 
-  // This method does the check for muting/nmuting the audio channel.
-  nsresult UpdateChannelMuteState(float aVolume, bool aMuted);
+  // This method does the check for muting/fading/unmuting the audio channel.
+  nsresult UpdateChannelMuteState(mozilla::dom::AudioChannelState aCanPlay);
 
   // Seeks to aTime seconds. aSeekType can be Exact to seek to exactly the
   // seek target, or PrevSyncPoint if a quicker but less precise seek is
@@ -1362,8 +1363,8 @@ protected:
   // Audio Channel.
   AudioChannel mAudioChannel;
 
-  // The audio channel volume
-  float mAudioChannelVolume;
+  // The audio channel has been faded.
+  bool mAudioChannelFaded;
 
   // Is this media element playing?
   bool mPlayingThroughTheAudioChannel;
diff --git a/dom/html/nsBrowserElement.cpp b/dom/html/nsBrowserElement.cpp
index 9db55877053..5a84096d80f 100644
--- a/dom/html/nsBrowserElement.cpp
+++ b/dom/html/nsBrowserElement.cpp
@@ -9,21 +9,15 @@
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
 #include "mozilla/dom/BrowserElementBinding.h"
-#include "mozilla/dom/BrowserElementAudioChannel.h"
 #include "mozilla/dom/DOMRequest.h"
 #include "mozilla/dom/ScriptSettings.h"
 #include "mozilla/dom/ToJSValue.h"
 
-#include "AudioChannelService.h"
-
-#include "mozIApplication.h"
 #include "nsComponentManagerUtils.h"
 #include "nsContentUtils.h"
 #include "nsFrameLoader.h"
-#include "nsIAppsService.h"
 #include "nsIDOMDOMRequest.h"
 #include "nsIDOMElement.h"
-#include "nsIMozBrowserFrame.h"
 #include "nsINode.h"
 #include "nsIPrincipal.h"
 
@@ -513,141 +507,6 @@ nsBrowserElement::SetInputMethodActive(bool aIsActive,
   return req.forget().downcast<DOMRequest>();
 }
 
-void
-nsBrowserElement::GetAllowedAudioChannels(
-                 nsTArray<nsRefPtr<BrowserElementAudioChannel>>& aAudioChannels,
-                 ErrorResult& aRv)
-{
-  aAudioChannels.Clear();
-
-  NS_ENSURE_TRUE_VOID(IsBrowserElementOrThrow(aRv));
-  NS_ENSURE_TRUE_VOID(IsNotWidgetOrThrow(aRv));
-
-  // If empty, it means that this is the first call of this method.
-  if (mBrowserElementAudioChannels.IsEmpty()) {
-    nsCOMPtr<nsIFrameLoader> frameLoader = GetFrameLoader();
-    if (!frameLoader) {
-      aRv.Throw(NS_ERROR_FAILURE);
-      return;
-    }
-
-    nsCOMPtr<nsIDOMElement> frameElement;
-    aRv = frameLoader->GetOwnerElement(getter_AddRefs(frameElement));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return;
-    }
-
-    MOZ_ASSERT(frameElement);
-
-    nsCOMPtr<nsIDOMDocument> doc;
-    aRv = frameElement->GetOwnerDocument(getter_AddRefs(doc));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return;
-    }
-
-    MOZ_ASSERT(doc);
-
-    nsCOMPtr<nsIDOMWindow> win;
-    aRv = doc->GetDefaultView(getter_AddRefs(win));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return;
-    }
-
-    MOZ_ASSERT(win);
-
-    nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(win);
-
-    if (!window->IsInnerWindow()) {
-      window = window->GetCurrentInnerWindow();
-    }
-
-    nsCOMPtr<nsIMozBrowserFrame> mozBrowserFrame =
-      do_QueryInterface(frameElement);
-    if (NS_WARN_IF(!mozBrowserFrame)) {
-      aRv.Throw(NS_ERROR_FAILURE);
-      return;
-    }
-
-    nsAutoString manifestURL;
-    aRv = mozBrowserFrame->GetAppManifestURL(manifestURL);
-    if (NS_WARN_IF(aRv.Failed())) {
-      return;
-    }
-
-    nsCOMPtr<nsIAppsService> appsService =
-      do_GetService("@mozilla.org/AppsService;1");
-    if (NS_WARN_IF(!appsService)) {
-      aRv.Throw(NS_ERROR_FAILURE);
-      return;
-    }
-
-    nsCOMPtr<mozIApplication> app;
-    aRv = appsService->GetAppByManifestURL(manifestURL, getter_AddRefs(app));
-    if (NS_WARN_IF(aRv.Failed())) {
-      return;
-    }
-
-    bool noapp = false;
-    Preferences::GetBool("dom.testing.browserElementAudioChannel.noapp", &noapp);
-
-    if (!noapp && !app) {
-      aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
-      return;
-    }
-
-    // Normal is always allowed.
-    nsTArray<nsRefPtr<BrowserElementAudioChannel>> channels;
-
-    nsRefPtr<BrowserElementAudioChannel> ac =
-      new BrowserElementAudioChannel(window, frameLoader, mBrowserElementAPI,
-                                     AudioChannel::Normal);
-
-    aRv = ac->Initialize();
-    if (NS_WARN_IF(aRv.Failed())) {
-      return;
-    }
-
-    channels.AppendElement(ac);
-
-    // app can be null in case we are in a test.
-    if (app) {
-      const nsAttrValue::EnumTable* audioChannelTable =
-        AudioChannelService::GetAudioChannelTable();
-
-      bool allowed;
-      nsAutoCString permissionName;
-
-      for (uint32_t i = 0; audioChannelTable && audioChannelTable[i].tag; ++i) {
-        permissionName.AssignASCII("audio-channel-");
-        permissionName.AppendASCII(audioChannelTable[i].tag);
-
-        aRv = app->HasPermission(permissionName.get(), &allowed);
-        if (NS_WARN_IF(aRv.Failed())) {
-          return;
-        }
-
-        if (allowed) {
-          nsRefPtr<BrowserElementAudioChannel> ac =
-            new BrowserElementAudioChannel(window, frameLoader,
-                                           mBrowserElementAPI,
-                                           (AudioChannel)audioChannelTable[i].value);
-
-          aRv = ac->Initialize();
-          if (NS_WARN_IF(aRv.Failed())) {
-            return;
-          }
-
-          channels.AppendElement(ac);
-        }
-      }
-    }
-
-    mBrowserElementAudioChannels.AppendElements(channels);
-  }
-
-  aAudioChannels.AppendElements(mBrowserElementAudioChannels);
-}
-
 void
 nsBrowserElement::SetNFCFocus(bool aIsFocus,
                               ErrorResult& aRv)
diff --git a/dom/html/nsBrowserElement.h b/dom/html/nsBrowserElement.h
index 45e128ba095..d30c8b3c219 100644
--- a/dom/html/nsBrowserElement.h
+++ b/dom/html/nsBrowserElement.h
@@ -8,7 +8,6 @@
 #define nsBrowserElement_h
 
 #include "mozilla/dom/BindingDeclarations.h"
-#include "mozilla/dom/BrowserElementAudioChannel.h"
 
 #include "nsCOMPtr.h"
 #include "nsIBrowserElementAPI.h"
@@ -71,10 +70,6 @@ public:
 
   already_AddRefed<dom::DOMRequest> PurgeHistory(ErrorResult& aRv);
 
-  void GetAllowedAudioChannels(
-            nsTArray<nsRefPtr<dom::BrowserElementAudioChannel>>& aAudioChannels,
-            ErrorResult& aRv);
-
   already_AddRefed<dom::DOMRequest>
   GetScreenshot(uint32_t aWidth,
                 uint32_t aHeight,
@@ -107,7 +102,6 @@ protected:
   NS_IMETHOD_(already_AddRefed<nsFrameLoader>) GetFrameLoader() = 0;
   void InitBrowserElementAPI();
   nsCOMPtr<nsIBrowserElementAPI> mBrowserElementAPI;
-  nsTArray<nsRefPtr<dom::BrowserElementAudioChannel>> mBrowserElementAudioChannels;
 
 private:
   bool IsBrowserElementOrThrow(ErrorResult& aRv);
diff --git a/dom/html/nsGenericHTMLFrameElement.cpp b/dom/html/nsGenericHTMLFrameElement.cpp
index 4e31ee24918..650be5d6435 100644
--- a/dom/html/nsGenericHTMLFrameElement.cpp
+++ b/dom/html/nsGenericHTMLFrameElement.cpp
@@ -6,7 +6,6 @@
 
 #include "nsGenericHTMLFrameElement.h"
 
-#include "mozilla/dom/BrowserElementAudioChannel.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/ErrorResult.h"
@@ -35,20 +34,8 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsGenericHTMLFrameElement,
                                                   nsGenericHTMLElement)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrameLoader)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserElementAPI)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserElementAudioChannels)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsGenericHTMLFrameElement,
-                                                nsGenericHTMLElement)
-  if (tmp->mFrameLoader) {
-    tmp->mFrameLoader->Destroy();
-  }
-
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrameLoader)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserElementAPI)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserElementAudioChannels)
-NS_IMPL_CYCLE_COLLECTION_UNLINK_END
-
 NS_IMPL_ADDREF_INHERITED(nsGenericHTMLFrameElement, nsGenericHTMLElement)
 NS_IMPL_RELEASE_INHERITED(nsGenericHTMLFrameElement, nsGenericHTMLElement)
 
diff --git a/dom/html/nsGenericHTMLFrameElement.h b/dom/html/nsGenericHTMLFrameElement.h
index 71ea4cc593a..e09815610b2 100644
--- a/dom/html/nsGenericHTMLFrameElement.h
+++ b/dom/html/nsGenericHTMLFrameElement.h
@@ -71,8 +71,8 @@ public:
 
   virtual int32_t TabIndexDefault() override;
 
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsGenericHTMLFrameElement,
-                                           nsGenericHTMLElement)
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_NO_UNLINK(nsGenericHTMLFrameElement,
+                                                     nsGenericHTMLElement)
 
   void SwapFrameLoaders(nsXULElement& aOtherOwner, mozilla::ErrorResult& aError);
 
diff --git a/dom/ipc/ContentChild.cpp b/dom/ipc/ContentChild.cpp
index b4acda4172d..1ff2fdde316 100644
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -182,6 +182,7 @@
 #include "nsContentUtils.h"
 #include "nsIPrincipal.h"
 #include "nsDeviceStorage.h"
+#include "AudioChannelService.h"
 #include "DomainPolicy.h"
 #include "mozilla/dom/DataStoreService.h"
 #include "mozilla/dom/telephony/PTelephonyChild.h"
@@ -942,6 +943,17 @@ NS_IMETHODIMP MemoryReportRequestChild::Run()
     return sent ? NS_OK : NS_ERROR_FAILURE;
 }
 
+bool
+ContentChild::RecvAudioChannelNotify()
+{
+    nsRefPtr<AudioChannelService> service =
+        AudioChannelService::GetAudioChannelService();
+    if (service) {
+        service->Notify();
+    }
+    return true;
+}
+
 bool
 ContentChild::RecvDataStoreNotify(const uint32_t& aAppId,
                                   const nsString& aName,
diff --git a/dom/ipc/ContentChild.h b/dom/ipc/ContentChild.h
index 21b5a2d6f5d..78fa38d28f0 100644
--- a/dom/ipc/ContentChild.h
+++ b/dom/ipc/ContentChild.h
@@ -200,6 +200,9 @@ public:
                                          const FileDescriptor& aGCLog,
                                          const FileDescriptor& aCCLog) override;
 
+    virtual bool
+    RecvAudioChannelNotify() override;
+
     virtual bool
     RecvDataStoreNotify(const uint32_t& aAppId, const nsString& aName,
                         const nsString& aManifestURL) override;
diff --git a/dom/ipc/ContentParent.cpp b/dom/ipc/ContentParent.cpp
index fca07860e16..b3d3f846a60 100755
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -2791,11 +2791,64 @@ ContentParent::RecvFirstIdle()
     return true;
 }
 
+bool
+ContentParent::RecvAudioChannelGetState(const AudioChannel& aChannel,
+                                        const bool& aElementHidden,
+                                        const bool& aElementWasHidden,
+                                        AudioChannelState* aState)
+{
+    nsRefPtr<AudioChannelService> service =
+        AudioChannelService::GetOrCreateAudioChannelService();
+    *aState = AUDIO_CHANNEL_STATE_NORMAL;
+    MOZ_ASSERT(service);
+    *aState = service->GetStateInternal(aChannel, mChildID,
+                                        aElementHidden, aElementWasHidden);
+
+    return true;
+}
+
+bool
+ContentParent::RecvAudioChannelRegisterType(const AudioChannel& aChannel,
+                                            const bool& aWithVideo)
+{
+    nsRefPtr<AudioChannelService> service =
+        AudioChannelService::GetOrCreateAudioChannelService();
+    MOZ_ASSERT(service);
+    service->RegisterType(aChannel, mChildID, aWithVideo);
+
+    return true;
+}
+
+bool
+ContentParent::RecvAudioChannelUnregisterType(const AudioChannel& aChannel,
+                                              const bool& aElementHidden,
+                                              const bool& aWithVideo)
+{
+    nsRefPtr<AudioChannelService> service =
+        AudioChannelService::GetOrCreateAudioChannelService();
+    MOZ_ASSERT(service);
+    service->UnregisterType(aChannel, aElementHidden, mChildID, aWithVideo);
+
+    return true;
+}
+
+bool
+ContentParent::RecvAudioChannelChangedNotification()
+{
+    nsRefPtr<AudioChannelService> service =
+        AudioChannelService::GetOrCreateAudioChannelService();
+    MOZ_ASSERT(service);
+    service->SendAudioChannelChangedNotification(ChildID());
+
+    return true;
+}
+
 bool
 ContentParent::RecvAudioChannelChangeDefVolChannel(const int32_t& aChannel,
                                                    const bool& aHidden)
 {
-    nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+    nsRefPtr<AudioChannelService> service =
+        AudioChannelService::GetOrCreateAudioChannelService();
     MOZ_ASSERT(service);
     service->SetDefaultVolumeControlChannelInternal(aChannel,
                                                     aHidden, mChildID);
diff --git a/dom/ipc/ContentParent.h b/dom/ipc/ContentParent.h
index 666e1f3d373..11e6f8bd1b8 100644
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -752,6 +752,19 @@ private:
 
     virtual bool RecvFirstIdle() override;
 
+    virtual bool RecvAudioChannelGetState(const AudioChannel& aChannel,
+                                          const bool& aElementHidden,
+                                          const bool& aElementWasHidden,
+                                          AudioChannelState* aValue) override;
+
+    virtual bool RecvAudioChannelRegisterType(const AudioChannel& aChannel,
+                                              const bool& aWithVideo) override;
+    virtual bool RecvAudioChannelUnregisterType(const AudioChannel& aChannel,
+                                                const bool& aElementHidden,
+                                                const bool& aWithVideo) override;
+
+    virtual bool RecvAudioChannelChangedNotification() override;
+
     virtual bool RecvAudioChannelChangeDefVolChannel(const int32_t& aChannel,
                                                      const bool& aHidden) override;
     virtual bool RecvGetSystemMemory(const uint64_t& getterId) override;
diff --git a/dom/ipc/PBrowser.ipdl b/dom/ipc/PBrowser.ipdl
index 54865fd13c3..49495f9df33 100644
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -548,10 +548,6 @@ parent:
     InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action,
                       nsCString visualData, uint32_t width, uint32_t height,
                       uint32_t stride, uint8_t format, int32_t dragAreaX, int32_t dragAreaY);
-
-    async AudioChannelActivityNotification(uint32_t aAudioChannel,
-                                           bool aActive);
-
 child:
     /**
      * Notify the remote browser that it has been Show()n on this
diff --git a/dom/ipc/PContent.ipdl b/dom/ipc/PContent.ipdl
index 5d00f497daf..222e31c086b 100644
--- a/dom/ipc/PContent.ipdl
+++ b/dom/ipc/PContent.ipdl
@@ -81,6 +81,8 @@ using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
 using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
 using mozilla::dom::asmjscache::OpenMode from "mozilla/dom/asmjscache/AsmJSCache.h";
 using mozilla::dom::asmjscache::WriteParams from "mozilla/dom/asmjscache/AsmJSCache.h";
+using mozilla::dom::AudioChannel from "mozilla/dom/AudioChannelBinding.h";
+using mozilla::dom::AudioChannelState from "AudioChannelCommon.h";
 using mozilla::dom::NativeThreadId from "mozilla/dom/TabMessageUtils.h";
 using mozilla::dom::quota::PersistenceType from "mozilla/dom/quota/PersistenceType.h";
 using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";
@@ -496,6 +498,11 @@ child:
     PMemoryReportRequest(uint32_t generation, bool anonymize,
                          bool minimizeMemoryUsage, MaybeFileDesc DMDFile);
 
+    /**
+     * Notify the AudioChannelService in the child processes.
+     */
+    async AudioChannelNotify();
+
     async SpeakerManagerNotify();
 
     /**
@@ -864,6 +871,17 @@ parent:
     // Tell the parent that the child has gone idle for the first time
     async FirstIdle();
 
+    // Get Muted from the main AudioChannelService.
+    sync AudioChannelGetState(AudioChannel aChannel, bool aElementHidden,
+                              bool aElementWasHidden)
+        returns (AudioChannelState value);
+
+    sync AudioChannelRegisterType(AudioChannel aChannel, bool aWithVideo);
+    sync AudioChannelUnregisterType(AudioChannel aChannel,
+                                    bool aElementHidden,
+                                    bool aWithVideo);
+
+    async AudioChannelChangedNotification();
     async AudioChannelChangeDefVolChannel(int32_t aChannel, bool aHidden);
 
     sync DataStoreGetStores(nsString aName, nsString aOwner, Principal aPrincipal)
diff --git a/dom/ipc/ProcessPriorityManager.cpp b/dom/ipc/ProcessPriorityManager.cpp
index e1b5909ce3a..ff2fe1a5cff 100644
--- a/dom/ipc/ProcessPriorityManager.cpp
+++ b/dom/ipc/ProcessPriorityManager.cpp
@@ -1041,7 +1041,7 @@ ParticularProcessPriorityManager::ComputePriority()
     return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;
   }
 
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  AudioChannelService* service = AudioChannelService::GetOrCreateAudioChannelService();
   if (service->ProcessContentOrNormalChannelIsActive(ChildID())) {
     return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;
   }
diff --git a/dom/ipc/TabChild.cpp b/dom/ipc/TabChild.cpp
index 78ec49c54ba..eaf045356a7 100644
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -890,22 +890,6 @@ TabChild::TabChild(nsIContentChild* aManager,
     MOZ_ASSERT(NestedTabChildMap().find(mUniqueId) == NestedTabChildMap().end());
     NestedTabChildMap()[mUniqueId] = this;
   }
-
-  nsCOMPtr<nsIObserverService> observerService =
-    mozilla::services::GetObserverService();
-
-  if (observerService) {
-    const nsAttrValue::EnumTable* table =
-      AudioChannelService::GetAudioChannelTable();
-
-    nsAutoCString topic;
-    for (uint32_t i = 0; table[i].tag; ++i) {
-      topic.Assign("audiochannel-activity-");
-      topic.Append(table[i].tag);
-
-      observerService->AddObserver(this, topic.get(), false);
-    }
-  }
 }
 
 NS_IMETHODIMP
@@ -973,27 +957,6 @@ TabChild::Observe(nsISupports *aSubject,
     }
   }
 
-  const nsAttrValue::EnumTable* table =
-    AudioChannelService::GetAudioChannelTable();
-
-  nsAutoCString topic;
-  int16_t audioChannel = -1;
-  for (uint32_t i = 0; table[i].tag; ++i) {
-    topic.Assign("audiochannel-activity-");
-    topic.Append(table[i].tag);
-
-    if (topic.Equals(aTopic)) {
-      audioChannel = table[i].value;
-      break;
-    }
-  }
-
-  if (audioChannel != -1) {
-    nsAutoString active(aData);
-    unused << SendAudioChannelActivityNotification(audioChannel,
-                                                   active.Equals(NS_LITERAL_STRING("active")));
-  }
-
   return NS_OK;
 }
 
@@ -2856,17 +2819,6 @@ TabChild::RecvDestroy()
   observerService->RemoveObserver(this, BROWSER_ZOOM_TO_RECT);
   observerService->RemoveObserver(this, BEFORE_FIRST_PAINT);
 
-  const nsAttrValue::EnumTable* table =
-    AudioChannelService::GetAudioChannelTable();
-
-  nsAutoCString topic;
-  for (uint32_t i = 0; table[i].tag; ++i) {
-    topic.Assign("audiochannel-activity-");
-    topic.Append(table[i].tag);
-
-    observerService->RemoveObserver(this, topic.get());
-  }
-
   // XXX what other code in ~TabChild() should we be running here?
   DestroyWindow();
 
diff --git a/dom/ipc/TabMessageUtils.h b/dom/ipc/TabMessageUtils.h
index b2e3beef244..adfa04735f7 100644
--- a/dom/ipc/TabMessageUtils.h
+++ b/dom/ipc/TabMessageUtils.h
@@ -7,6 +7,7 @@
 #ifndef TABMESSAGE_UTILS_H
 #define TABMESSAGE_UTILS_H
 
+#include "AudioChannelCommon.h"
 #include "ipc/IPCMessageUtils.h"
 #include "mozilla/dom/AudioChannelBinding.h"
 #include "nsIDOMEvent.h"
@@ -88,6 +89,14 @@ struct ParamTraits<mozilla::dom::AudioChannel>
   }
 };
 
+template <>
+struct ParamTraits<mozilla::dom::AudioChannelState>
+  : public ContiguousEnumSerializer<mozilla::dom::AudioChannelState,
+                                    mozilla::dom::AUDIO_CHANNEL_STATE_NORMAL,
+                                    mozilla::dom::AUDIO_CHANNEL_STATE_LAST>
+{ };
+
+
 template <>
 struct ParamTraits<nsEventStatus>
   : public ContiguousEnumSerializer<nsEventStatus,
diff --git a/dom/ipc/TabParent.cpp b/dom/ipc/TabParent.cpp
index f76e0f8bb84..5554c72be4a 100644
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -8,7 +8,6 @@
 
 #include "TabParent.h"
 
-#include "AudioChannelService.h"
 #include "AppProcessChecker.h"
 #include "mozIApplication.h"
 #ifdef ACCESSIBILITY
@@ -2647,29 +2646,6 @@ TabParent::RecvGetRenderFrameInfo(PRenderFrameParent* aRenderFrame,
   return true;
 }
 
-bool
-TabParent::RecvAudioChannelActivityNotification(const uint32_t& aAudioChannel,
-                                                const bool& aActive)
-{
-  if (aAudioChannel >= NUMBER_OF_AUDIO_CHANNELS) {
-    return false;
-  }
-
-  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
-  if (os) {
-    nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
-    nsAutoCString topic;
-    topic.Assign("audiochannel-activity-");
-    topic.Append(AudioChannelService::GetAudioChannelTable()[aAudioChannel].tag);
-
-    os->NotifyObservers(NS_ISUPPORTS_CAST(nsITabParent*, this),
-                        topic.get(),
-                        aActive ? MOZ_UTF16("active") : MOZ_UTF16("inactive"));
-  }
-
-  return true;
-}
-
 already_AddRefed<nsFrameLoader>
 TabParent::GetFrameLoader(bool aUseCachedFrameLoaderAfterDestroy) const
 {
diff --git a/dom/ipc/TabParent.h b/dom/ipc/TabParent.h
index 7b57957e61b..9033da6ff5a 100644
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -462,9 +462,6 @@ protected:
                                    const int32_t& aX, const int32_t& aY,
                                    const int32_t& aCx, const int32_t& aCy) override;
 
-    virtual bool RecvAudioChannelActivityNotification(const uint32_t& aAudioChannel,
-                                                      const bool& aActive) override;
-
     bool InitBrowserConfiguration(const nsCString& aURI,
                                   BrowserConfiguration& aConfiguration);
 
diff --git a/dom/media/webaudio/AudioDestinationNode.cpp b/dom/media/webaudio/AudioDestinationNode.cpp
index 252a8ba7027..6219dec720b 100644
--- a/dom/media/webaudio/AudioDestinationNode.cpp
+++ b/dom/media/webaudio/AudioDestinationNode.cpp
@@ -298,11 +298,44 @@ static bool UseAudioChannelAPI()
   return Preferences::GetBool("media.useAudioChannelAPI");
 }
 
+class EventProxyHandler final : public nsIDOMEventListener
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit EventProxyHandler(nsIDOMEventListener* aNode)
+  {
+    MOZ_ASSERT(aNode);
+    mWeakNode = do_GetWeakReference(aNode);
+  }
+
+  // nsIDOMEventListener
+  NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent) override
+  {
+    nsCOMPtr<nsIDOMEventListener> listener = do_QueryReferent(mWeakNode);
+    if (!listener) {
+      return NS_OK;
+    }
+
+    auto node = static_cast<AudioDestinationNode*>(listener.get());
+    return node->HandleEvent(aEvent);
+  }
+
+private:
+  ~EventProxyHandler()
+  { }
+
+  nsWeakPtr mWeakNode;
+};
+
+NS_IMPL_ISUPPORTS(EventProxyHandler, nsIDOMEventListener)
+
 NS_IMPL_CYCLE_COLLECTION_INHERITED(AudioDestinationNode, AudioNode,
-                                   mAudioChannelAgent,
+                                   mAudioChannelAgent, mEventProxyHelper,
                                    mOfflineRenderingPromise)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(AudioDestinationNode)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
   NS_INTERFACE_MAP_ENTRY(nsIAudioChannelAgentCallback)
 NS_INTERFACE_MAP_END_INHERITING(AudioNode)
 
@@ -375,6 +408,13 @@ AudioDestinationNode::DestroyAudioChannelAgent()
   if (mAudioChannelAgent && !Context()->IsOffline()) {
     mAudioChannelAgent->StopPlaying();
     mAudioChannelAgent = nullptr;
+
+    nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(GetOwner());
+    NS_ENSURE_TRUE_VOID(target);
+
+    target->RemoveSystemEventListener(NS_LITERAL_STRING("visibilitychange"),
+                                      mEventProxyHelper,
+                                      /* useCapture = */ true);
   }
 }
 
@@ -478,30 +518,65 @@ AudioDestinationNode::StartRendering(Promise* aPromise)
 }
 
 void
-AudioDestinationNode::SetCanPlay(float aVolume, bool aMuted)
+AudioDestinationNode::SetCanPlay(bool aCanPlay)
 {
-  if (!mStream) {
-    return;
-  }
-
-  mStream->SetTrackEnabled(AudioNodeStream::AUDIO_TRACK, !aMuted);
-  mStream->SetAudioOutputVolume(&gWebAudioOutputKey, aVolume);
+  mStream->SetTrackEnabled(AudioNodeStream::AUDIO_TRACK, aCanPlay);
 }
 
 NS_IMETHODIMP
-AudioDestinationNode::WindowVolumeChanged(float aVolume, bool aMuted)
+AudioDestinationNode::HandleEvent(nsIDOMEvent* aEvent)
 {
-  if (aMuted != mAudioChannelAgentPlaying) {
-    mAudioChannelAgentPlaying = aMuted;
+  nsAutoString type;
+  aEvent->GetType(type);
 
-    if (UseAudioChannelAPI()) {
-      Context()->DispatchTrustedEvent(
-        !aMuted ? NS_LITERAL_STRING("mozinterruptend")
-                : NS_LITERAL_STRING("mozinterruptbegin"));
-    }
+  if (!type.EqualsLiteral("visibilitychange")) {
+    return NS_ERROR_FAILURE;
   }
 
-  SetCanPlay(aVolume, aMuted);
+  nsCOMPtr<nsIDocShell> docshell = do_GetInterface(GetOwner());
+  NS_ENSURE_TRUE(docshell, NS_ERROR_FAILURE);
+
+  bool isActive = false;
+  docshell->GetIsActive(&isActive);
+
+  mAudioChannelAgent->SetVisibilityState(isActive);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+AudioDestinationNode::CanPlayChanged(int32_t aCanPlay)
+{
+  bool playing = aCanPlay == AudioChannelState::AUDIO_CHANNEL_STATE_NORMAL;
+  if (playing == mAudioChannelAgentPlaying) {
+    return NS_OK;
+  }
+
+  mAudioChannelAgentPlaying = playing;
+  SetCanPlay(playing);
+
+  if (UseAudioChannelAPI()) {
+    Context()->DispatchTrustedEvent(
+      playing ? NS_LITERAL_STRING("mozinterruptend")
+              : NS_LITERAL_STRING("mozinterruptbegin"));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+AudioDestinationNode::WindowVolumeChanged()
+{
+  MOZ_ASSERT(mAudioChannelAgent);
+
+  if (!mStream) {
+    return NS_OK;
+  }
+
+  float volume;
+  nsresult rv = mAudioChannelAgent->GetWindowVolume(&volume);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mStream->SetAudioOutputVolume(&gWebAudioOutputKey, volume);
   return NS_OK;
 }
 
@@ -579,6 +654,20 @@ AudioDestinationNode::CreateAudioChannelAgent()
     return;
   }
 
+  if (!mEventProxyHelper) {
+    nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(GetOwner());
+    if (target) {
+      // We use a proxy because otherwise the event listerner would hold a
+      // reference of the destination node, and by extension, everything
+      // connected to it.
+      mEventProxyHelper = new EventProxyHandler(this);
+      target->AddSystemEventListener(NS_LITERAL_STRING("visibilitychange"),
+                                     mEventProxyHelper,
+                                     /* useCapture = */ true,
+                                     /* wantsUntrusted = */ false);
+    }
+  }
+
   if (mAudioChannelAgent) {
     mAudioChannelAgent->StopPlaying();
   }
@@ -588,9 +677,16 @@ AudioDestinationNode::CreateAudioChannelAgent()
                                            static_cast<int32_t>(mAudioChannel),
                                            this);
 
-  // The AudioChannelAgent must start playing immediately in order to avoid
-  // race conditions with mozinterruptbegin/end events.
-  InputMuted(false);
+  nsCOMPtr<nsIDocShell> docshell = do_GetInterface(GetOwner());
+  if (docshell) {
+    bool isActive = false;
+    docshell->GetIsActive(&isActive);
+    mAudioChannelAgent->SetVisibilityState(isActive);
+
+    // The AudioChannelAgent must start playing immediately in order to avoid
+    // race conditions with mozinterruptbegin/end events.
+    InputMuted(false);
+  }
 }
 
 void
@@ -675,14 +771,13 @@ AudioDestinationNode::InputMuted(bool aMuted)
     return;
   }
 
-  float volume = 0.0;
-  bool muted = true;
-  nsresult rv = mAudioChannelAgent->StartPlaying(&volume, &muted);
+  int32_t state = 0;
+  nsresult rv = mAudioChannelAgent->StartPlaying(&state);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return;
   }
 
-  WindowVolumeChanged(volume, muted);
+  CanPlayChanged(state);
 }
 
 } // dom namespace
diff --git a/dom/media/webaudio/AudioDestinationNode.h b/dom/media/webaudio/AudioDestinationNode.h
index f5f6865d7b5..7c774636813 100644
--- a/dom/media/webaudio/AudioDestinationNode.h
+++ b/dom/media/webaudio/AudioDestinationNode.h
@@ -9,14 +9,18 @@
 
 #include "mozilla/dom/AudioChannelBinding.h"
 #include "AudioNode.h"
+#include "nsIDOMEventListener.h"
 #include "nsIAudioChannelAgent.h"
+#include "AudioChannelCommon.h"
 
 namespace mozilla {
 namespace dom {
 
 class AudioContext;
+class EventProxyHandler;
 
 class AudioDestinationNode final : public AudioNode
+                                 , public nsIDOMEventListener
                                  , public nsIAudioChannelAgentCallback
                                  , public MainThreadMediaStreamListener
 {
@@ -57,6 +61,9 @@ public:
 
   void OfflineShutdown();
 
+  // nsIDOMEventListener - by proxy
+  NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent) override;
+
   AudioChannel MozAudioChannelType() const;
   void SetMozAudioChannelType(AudioChannel aValue, ErrorResult& aRv);
 
@@ -90,7 +97,7 @@ protected:
 private:
   bool CheckAudioChannelPermissions(AudioChannel aValue);
 
-  void SetCanPlay(float aVolume, bool aMuted);
+  void SetCanPlay(bool aCanPlay);
 
   void NotifyStableState();
   void ScheduleStableStateNotification();
@@ -100,6 +107,7 @@ private:
 
   nsCOMPtr<nsIAudioChannelAgent> mAudioChannelAgent;
 
+  nsRefPtr<EventProxyHandler> mEventProxyHelper;
   nsRefPtr<Promise> mOfflineRenderingPromise;
 
   // Audio Channel Type.
diff --git a/dom/media/webaudio/moz.build b/dom/media/webaudio/moz.build
index 3b08f093bcd..9b2ede5c984 100644
--- a/dom/media/webaudio/moz.build
+++ b/dom/media/webaudio/moz.build
@@ -18,6 +18,8 @@ MOCHITEST_MANIFESTS += [
 
 MOCHITEST_CHROME_MANIFESTS += ['test/chrome.ini']
 
+BROWSER_CHROME_MANIFESTS += ['test/browser.ini']
+
 EXPORTS += [
     'AlignedTArray.h',
     'AudioContext.h',
diff --git a/dom/media/webaudio/test/browser.ini b/dom/media/webaudio/test/browser.ini
new file mode 100644
index 00000000000..149c559a56b
--- /dev/null
+++ b/dom/media/webaudio/test/browser.ini
@@ -0,0 +1,8 @@
+[DEFAULT]
+support-files =
+  browser_mozAudioChannel.html
+  browser_mozAudioChannel_muted.html
+
+[browser_mozAudioChannel.js]
+[browser_mozAudioChannel_muted.js]
+skip-if = e10s
diff --git a/dom/media/webaudio/test/browser_mozAudioChannel.html b/dom/media/webaudio/test/browser_mozAudioChannel.html
new file mode 100644
index 00000000000..c92692fef77
--- /dev/null
+++ b/dom/media/webaudio/test/browser_mozAudioChannel.html
@@ -0,0 +1,33 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<meta charset="utf-8">
+<title>Test for mozinterruptbegin/end in AudioContext</title>
+
+<script type="application/javascript">
+
+  var ac = new AudioContext();
+
+  function createEvent(msg) {
+    var event = document.createEvent('CustomEvent');
+    event.initCustomEvent('testmozchannel', true, true, { msg: msg });
+    dispatchEvent(event);
+  }
+
+  ac.onmozinterruptbegin = function(evt) {
+    createEvent('mozinterruptbegin');
+  }
+
+  ac.addEventListener('mozinterruptend', function() {
+    createEvent('mozinterruptend');
+  }, false);
+
+  var buffer = ac.createBuffer(1, 2048, ac.sampleRate);
+  for (var i = 0; i < 2048; ++i) {
+    buffer.getChannelData(0)[i] = Math.sin(440 * 2 * Math.PI * i / ac.sampleRate);
+  }
+
+  var source = ac.createBufferSource();
+  source.buffer = buffer;
+  source.connect(ac.destination);
+  source.loop = true;
+  source.start(0);
+</script>
diff --git a/dom/media/webaudio/test/browser_mozAudioChannel.js b/dom/media/webaudio/test/browser_mozAudioChannel.js
new file mode 100644
index 00000000000..ac85ae8e9cc
--- /dev/null
+++ b/dom/media/webaudio/test/browser_mozAudioChannel.js
@@ -0,0 +1,80 @@
+/* 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/. */
+
+function whenBrowserLoaded(aBrowser, aCallback) {
+  aBrowser.addEventListener("load", function onLoad(event) {
+    if (event.target == aBrowser.contentDocument) {
+      aBrowser.removeEventListener("load", onLoad, true);
+      executeSoon(aCallback);
+    }
+  }, true);
+}
+
+function whenBrowserUnloaded(aBrowser, aCallback) {
+  aBrowser.addEventListener("unload", function onUnload() {
+    aBrowser.removeEventListener("unload", onUnload, true);
+    executeSoon(aCallback);
+  }, true);
+}
+
+var event;
+var next = function() {}
+
+function eventListener(evt) {
+  info("Event has been received!");
+  is(evt.detail.msg, event, "AudioContext has been received the right event: " + event);
+  next();
+}
+
+function test() {
+
+  waitForExplicitFinish();
+
+  let testURL = "http://mochi.test:8888/browser/" +
+    "dom/media/webaudio/test/browser_mozAudioChannel.html";
+
+  SpecialPowers.pushPrefEnv({"set": [["media.defaultAudioChannel", "content" ],
+                                     ["media.useAudioChannelAPI", true ],
+                                     ["media.useAudioChannelService", true ]]},
+    function() {
+      let tab1 = gBrowser.addTab(testURL);
+      gBrowser.selectedTab = tab1;
+
+      whenBrowserLoaded(tab1.linkedBrowser, function() {
+        let doc = tab1.linkedBrowser.contentDocument;
+        tab1.linkedBrowser.contentWindow.addEventListener('testmozchannel', eventListener, false);
+
+        SpecialPowers.pushPrefEnv({"set": [["media.defaultAudioChannel", "telephony" ]]},
+          function() {
+            event = 'mozinterruptbegin';
+            next = function() {
+              info("Next is called.");
+              event = 'mozinterruptend';
+              next =  function() {
+                info("Next is called again.");
+                tab1.linkedBrowser.contentWindow.removeEventListener('testmozchannel', eventListener);
+                gBrowser.removeTab(tab1);
+                finish();
+              }
+
+              info("Unloading a tab...");
+              whenBrowserUnloaded(tab2.linkedBrowser, function() { info("Tab unloaded."); });
+
+              executeSoon(function() {
+                gBrowser.removeTab(tab2);
+                gBrowser.selectedTab = tab1;
+              });
+            }
+
+            let tab2 = gBrowser.addTab(testURL);
+            gBrowser.selectedTab = tab2;
+
+            info("Loading the tab...");
+            whenBrowserLoaded(tab2.linkedBrowser, function() { info("Tab restored."); });
+          }
+        );
+      });
+    }
+  );
+}
diff --git a/dom/media/webaudio/test/browser_mozAudioChannel_muted.html b/dom/media/webaudio/test/browser_mozAudioChannel_muted.html
new file mode 100644
index 00000000000..095d4969e96
--- /dev/null
+++ b/dom/media/webaudio/test/browser_mozAudioChannel_muted.html
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<meta charset="utf-8">
+<title>Test for mozinterruptbegin/end in AudioContext</title>
+
+mozAudioChannelTest = <span id="mozAudioChannelTest">FAIL</span>
+
+<script type="application/javascript">
+
+  var ac = new AudioContext();
+
+  ac.onmozinterruptbegin = function(evt) {
+    document.getElementById("mozAudioChannelTest").innerHTML = "mozinterruptbegin";
+  }
+
+  ac.addEventListener('mozinterruptend', function() {
+    document.getElementById("mozAudioChannelTest").innerHTML = "mozinterruptend";
+  }, false);
+
+  document.getElementById("mozAudioChannelTest").innerHTML = "READY";
+
+</script>
diff --git a/dom/media/webaudio/test/browser_mozAudioChannel_muted.js b/dom/media/webaudio/test/browser_mozAudioChannel_muted.js
new file mode 100644
index 00000000000..4d43e1d810c
--- /dev/null
+++ b/dom/media/webaudio/test/browser_mozAudioChannel_muted.js
@@ -0,0 +1,72 @@
+/* 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/. */
+
+function whenBrowserLoaded(aBrowser, aCallback) {
+  aBrowser.addEventListener("load", function onLoad(event) {
+    if (event.target == aBrowser.contentDocument) {
+      aBrowser.removeEventListener("load", onLoad, true);
+      executeSoon(aCallback);
+    }
+  }, true);
+}
+
+function whenTabRestored(aTab, aCallback) {
+  aTab.addEventListener("SSTabRestored", function onRestored(aEvent) {
+    aTab.removeEventListener("SSTabRestored", onRestored, true);
+    executeSoon(function executeWhenTabRestored() {
+      aCallback();
+    });
+  }, true);
+}
+
+function whenBrowserUnloaded(aBrowser, aCallback) {
+  aBrowser.addEventListener("unload", function onUnload() {
+    aBrowser.removeEventListener("unload", onUnload, true);
+    executeSoon(aCallback);
+  }, true);
+}
+
+function test() {
+
+  waitForExplicitFinish();
+
+  let testURL = "http://mochi.test:8888/browser/" +
+    "dom/media/webaudio/test/browser_mozAudioChannel_muted.html";
+
+  SpecialPowers.pushPrefEnv({"set": [["media.defaultAudioChannel", "content" ],
+                                     ["media.useAudioChannelAPI", true ],
+                                     ["media.useAudioChannelService", true ]]},
+    function() {
+      let tab1 = gBrowser.addTab(testURL);
+      gBrowser.selectedTab = tab1;
+
+      whenBrowserLoaded(tab1.linkedBrowser, function() {
+        let doc = tab1.linkedBrowser.contentDocument;
+        is(doc.getElementById("mozAudioChannelTest").textContent, "READY",
+           "Test is ready to run");
+
+        SpecialPowers.pushPrefEnv({"set": [["media.defaultAudioChannel", "telephony" ]]},
+          function() {
+            let tab2 = gBrowser.duplicateTab(tab1);
+            gBrowser.selectedTab = tab2;
+            whenTabRestored(tab2, function() {
+              is(doc.getElementById("mozAudioChannelTest").textContent, "mozinterruptbegin",
+                 "AudioContext should be muted by the second tab.");
+
+              whenBrowserUnloaded(tab2.linkedBrowser, function() {
+                is(doc.getElementById("mozAudioChannelTest").textContent, "mozinterruptend",
+                   "AudioContext should be muted by the second tab.");
+                gBrowser.removeTab(tab1);
+                finish();
+              });
+
+              gBrowser.removeTab(tab2);
+              gBrowser.selectedTab = tab1;
+            });
+          }
+        );
+      });
+    }
+  );
+}
diff --git a/dom/speakermanager/SpeakerManager.cpp b/dom/speakermanager/SpeakerManager.cpp
index d848e011ab6..6bdedea11a2 100644
--- a/dom/speakermanager/SpeakerManager.cpp
+++ b/dom/speakermanager/SpeakerManager.cpp
@@ -201,8 +201,8 @@ SpeakerManager::HandleEvent(nsIDOMEvent* aEvent)
   // currently playing in the app itself, if application switch to
   // the background, we switch 'speakerforced' to false.
   if (!mVisible && mForcespeaker) {
-    nsRefPtr<AudioChannelService> audioChannelService =
-      AudioChannelService::GetOrCreate();
+    AudioChannelService* audioChannelService =
+      AudioChannelService::GetOrCreateAudioChannelService();
     if (audioChannelService && !audioChannelService->AnyAudioChannelIsActive()) {
       service->ForceSpeaker(false, mVisible);
     }
diff --git a/dom/speakermanager/SpeakerManagerService.cpp b/dom/speakermanager/SpeakerManagerService.cpp
index 5e2d59f8815..27d6ecb0b4d 100644
--- a/dom/speakermanager/SpeakerManagerService.cpp
+++ b/dom/speakermanager/SpeakerManagerService.cpp
@@ -194,15 +194,18 @@ SpeakerManagerService::SpeakerManagerService()
       obs->AddObserver(this, "ipc:content-shutdown", false);
     }
   }
-  nsRefPtr<AudioChannelService> audioChannelService =
-    AudioChannelService::GetOrCreate();
-  audioChannelService->RegisterSpeakerManager(this);
+  AudioChannelService* audioChannelService =
+    AudioChannelService::GetOrCreateAudioChannelService();
+  if (audioChannelService) {
+    audioChannelService->RegisterSpeakerManager(this);
+  }
 }
 
 SpeakerManagerService::~SpeakerManagerService()
 {
   MOZ_COUNT_DTOR(SpeakerManagerService);
-  nsRefPtr<AudioChannelService> audioChannelService =
-    AudioChannelService::GetOrCreate();
-  audioChannelService->UnregisterSpeakerManager(this);
+  AudioChannelService* audioChannelService =
+    AudioChannelService::GetOrCreateAudioChannelService();
+  if (audioChannelService)
+    audioChannelService->UnregisterSpeakerManager(this);
 }
diff --git a/dom/speakermanager/SpeakerManagerServiceChild.cpp b/dom/speakermanager/SpeakerManagerServiceChild.cpp
index a153fcd2ec3..fc8697d87f4 100644
--- a/dom/speakermanager/SpeakerManagerServiceChild.cpp
+++ b/dom/speakermanager/SpeakerManagerServiceChild.cpp
@@ -96,7 +96,7 @@ SpeakerManagerServiceChild::SetAudioChannelActive(bool aIsActive)
 SpeakerManagerServiceChild::SpeakerManagerServiceChild()
 {
   MOZ_ASSERT(NS_IsMainThread());
-  nsRefPtr<AudioChannelService> audioChannelService = AudioChannelService::GetOrCreate();
+  AudioChannelService* audioChannelService = AudioChannelService::GetOrCreateAudioChannelService();
   if (audioChannelService) {
     audioChannelService->RegisterSpeakerManager(this);
   }
@@ -105,7 +105,7 @@ SpeakerManagerServiceChild::SpeakerManagerServiceChild()
 
 SpeakerManagerServiceChild::~SpeakerManagerServiceChild()
 {
-  nsRefPtr<AudioChannelService> audioChannelService = AudioChannelService::GetOrCreate();
+  AudioChannelService* audioChannelService = AudioChannelService::GetOrCreateAudioChannelService();
   if (audioChannelService) {
     audioChannelService->UnregisterSpeakerManager(this);
   }
diff --git a/dom/system/gonk/AudioChannelManager.cpp b/dom/system/gonk/AudioChannelManager.cpp
index 417a86b9360..a961390417a 100644
--- a/dom/system/gonk/AudioChannelManager.cpp
+++ b/dom/system/gonk/AudioChannelManager.cpp
@@ -131,7 +131,7 @@ AudioChannelManager::NotifyVolumeControlChannelChanged()
   bool isActive = false;
   docshell->GetIsActive(&isActive);
 
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  AudioChannelService* service = AudioChannelService::GetOrCreateAudioChannelService();
   if (isActive) {
     service->SetDefaultVolumeControlChannel(mVolumeChannel, isActive);
   } else {
diff --git a/dom/system/gonk/AudioManager.cpp b/dom/system/gonk/AudioManager.cpp
index bf282cf6e18..3b639089f85 100644
--- a/dom/system/gonk/AudioManager.cpp
+++ b/dom/system/gonk/AudioManager.cpp
@@ -356,7 +356,7 @@ AudioManager::HandleAudioChannelProcessChanged()
     return;
   }
 
-  nsRefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  AudioChannelService *service = AudioChannelService::GetOrCreateAudioChannelService();
   MOZ_ASSERT(service);
 
   bool telephonyChannelIsActive = service->TelephonyChannelIsActive();
@@ -651,13 +651,8 @@ AudioManager::SetPhoneState(int32_t aState)
     }
 
     // Telephony can always play.
-    float volume = 0.0;
-    bool muted = true;
-
-    nsresult rv = mPhoneAudioAgent->StartPlaying(&volume, &muted);
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return rv;
-    }
+    int32_t canPlay;
+    mPhoneAudioAgent->StartPlaying(&canPlay);
   }
 
   return NS_OK;
diff --git a/dom/webidl/BrowserElementAudioChannel.webidl b/dom/webidl/BrowserElementAudioChannel.webidl
deleted file mode 100644
index e4c94de3013..00000000000
--- a/dom/webidl/BrowserElementAudioChannel.webidl
+++ /dev/null
@@ -1,37 +0,0 @@
-/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* 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/.
- */
-
-[Pref="dom.mozBrowserFramesEnabled",
- CheckPermissions="browser"]
-interface BrowserElementAudioChannel : EventTarget {
-  readonly attribute AudioChannel name;
-
-  // This event is dispatched when this audiochannel is actually in used by the
-  // app or one of the sub-iframes.
-  attribute EventHandler onactivestatechanged;
-
-  [Throws]
-  DOMRequest getVolume();
-
-  [Throws]
-  DOMRequest setVolume(float aVolume);
-
-  [Throws]
-  DOMRequest getMuted();
-
-  [Throws]
-  DOMRequest setMuted(boolean aMuted);
-
-  [Throws]
-  DOMRequest isActive();
-};
-
-partial interface BrowserElementPrivileged {
-  [Constant, Cached, Throws,
-   Pref="dom.mozBrowserFramesEnabled",
-   CheckPermissions="browser"]
-  readonly attribute sequence<BrowserElementAudioChannel> allowedAudioChannels;
-};
diff --git a/dom/webidl/moz.build b/dom/webidl/moz.build
index d2c10ef26f8..2d242ea4556 100644
--- a/dom/webidl/moz.build
+++ b/dom/webidl/moz.build
@@ -57,7 +57,6 @@ WEBIDL_FILES = [
     'BoxObject.webidl',
     'BroadcastChannel.webidl',
     'BrowserElement.webidl',
-    'BrowserElementAudioChannel.webidl',
     'BrowserElementDictionaries.webidl',
     'Cache.webidl',
     'CacheStorage.webidl',
diff --git a/layout/build/nsLayoutModule.cpp b/layout/build/nsLayoutModule.cpp
index ecd64f72bf6..0f243a59831 100644
--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -631,7 +631,7 @@ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(Geolocation, Init)
 
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsGeolocationService, nsGeolocationService::GetGeolocationService)
 
-NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(AudioChannelService, AudioChannelService::GetOrCreate)
+NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(AudioChannelService, AudioChannelService::GetOrCreateAudioChannelService)
 
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(DataStoreService, DataStoreService::GetOrCreate)