Backed out changeset dfbae87208dd (Bug 864327) for red
authorMichael Wu <mwu@mozilla.com>
Tue, 30 Sep 2014 13:39:43 -0400
changeset 208016 bfb2f705f6d94b5419c773be669422d80fe9f1d8
parent 208015 67aeca5b69a783752e005887f2a53af8c0e356d7
child 208017 a429129c1cebe67d94eb4fcb62521f5f24c1a37a
push id27571
push userkwierso@gmail.com
push dateTue, 30 Sep 2014 23:48:42 +0000
treeherdermozilla-central@633ae38b87d7 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs864327
milestone35.0a1
backs outdfbae87208dd532ab3280fb8b63837829174448b
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changeset dfbae87208dd (Bug 864327) for red
content/base/src/nsGkAtomList.h
dom/fmradio/FMRadio.cpp
dom/fmradio/FMRadio.h
dom/fmradio/FMRadioCommon.h
dom/fmradio/FMRadioService.cpp
dom/fmradio/FMRadioService.h
dom/fmradio/ipc/FMRadioChild.cpp
dom/fmradio/ipc/FMRadioChild.h
dom/fmradio/ipc/FMRadioParent.cpp
dom/fmradio/ipc/FMRadioParent.h
dom/fmradio/ipc/PFMRadio.ipdl
dom/webidl/FMRadio.webidl
--- a/content/base/src/nsGkAtomList.h
+++ b/content/base/src/nsGkAtomList.h
@@ -791,58 +791,51 @@ GK_ATOM(onmozfullscreenchange, "onmozful
 GK_ATOM(onmozfullscreenerror, "onmozfullscreenerror")
 GK_ATOM(onmozpointerlockchange, "onmozpointerlockchange")
 GK_ATOM(onmozpointerlockerror, "onmozpointerlockerror")
 GK_ATOM(onmoztimechange, "onmoztimechange")
 GK_ATOM(onMozMousePixelScroll, "onMozMousePixelScroll")
 GK_ATOM(onMozScrolledAreaChanged, "onMozScrolledAreaChanged")
 GK_ATOM(onmoznetworkupload, "onmoznetworkupload")
 GK_ATOM(onmoznetworkdownload, "onmoznetworkdownload")
-GK_ATOM(onnewrdsgroup, "onnewrdsgroup")
 GK_ATOM(onnoupdate, "onnoupdate")
 GK_ATOM(onobsolete, "onobsolete")
 GK_ATOM(ononline, "ononline")
 GK_ATOM(onoffline, "onoffline")
 GK_ATOM(onopen, "onopen")
 GK_ATOM(onotastatuschange, "onotastatuschange")
 GK_ATOM(onoverflow, "onoverflow")
 GK_ATOM(onoverflowchanged, "onoverflowchanged")
 GK_ATOM(onpagehide, "onpagehide")
 GK_ATOM(onpageshow, "onpageshow")
 GK_ATOM(onpaint, "onpaint")
 GK_ATOM(onpairedstatuschanged, "onpairedstatuschanged")
 GK_ATOM(onpairingconfirmationreq, "onpairingconfirmationreq")
 GK_ATOM(onpairingconsentreq, "onpairingconsentreq")
 GK_ATOM(onpaste, "onpaste")
 GK_ATOM(onpendingchange, "onpendingchange")
-GK_ATOM(onpichange, "onpichange")
 GK_ATOM(onpopuphidden, "onpopuphidden")
 GK_ATOM(onpopuphiding, "onpopuphiding")
 GK_ATOM(onpopupshowing, "onpopupshowing")
 GK_ATOM(onpopupshown, "onpopupshown")
-GK_ATOM(onpschange, "onpschange")
-GK_ATOM(onptychange, "onptychange")
 GK_ATOM(onradiostatechange, "onradiostatechange")
-GK_ATOM(onrdsdisabled, "onrdsdisabled")
-GK_ATOM(onrdsenabled, "onrdsenabled")
 GK_ATOM(onreaderror, "onreaderror")
 GK_ATOM(onreadsuccess, "onreadsuccess")
 GK_ATOM(onready, "onready")
 GK_ATOM(onreadystatechange, "onreadystatechange")
 GK_ATOM(onreceived, "onreceived")
 GK_ATOM(onremoteheld, "onremoteheld")
 GK_ATOM(onremoteresumed, "onremoteresumed")
 GK_ATOM(onresourcetimingbufferfull, "onresourcetimingbufferfull")
 GK_ATOM(onretrieving, "onretrieving")
 GK_ATOM(onRequest, "onRequest")
 GK_ATOM(onrequestmediaplaystatus, "onrequestmediaplaystatus")
 GK_ATOM(onreset, "onreset")
 GK_ATOM(onresuming, "onresuming")
 GK_ATOM(onresize, "onresize")
-GK_ATOM(onrtchange, "onrtchange")
 GK_ATOM(onscostatuschanged, "onscostatuschanged")
 GK_ATOM(onscroll, "onscroll")
 GK_ATOM(onselect, "onselect")
 GK_ATOM(onsending, "onsending")
 GK_ATOM(onsent, "onsent")
 GK_ATOM(onset, "onset")
 GK_ATOM(onshow, "onshow")
 GK_ATOM(onstatechange, "onstatechange")
--- a/dom/fmradio/FMRadio.cpp
+++ b/dom/fmradio/FMRadio.cpp
@@ -8,17 +8,16 @@
 #include "nsContentUtils.h"
 #include "mozilla/Hal.h"
 #include "mozilla/HalTypes.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/FMRadioBinding.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/dom/PFMRadioChild.h"
 #include "mozilla/dom/FMRadioService.h"
-#include "mozilla/dom/TypedArray.h"
 #include "DOMRequest.h"
 #include "nsDOMClassInfo.h"
 #include "nsIDocShell.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsIAudioManager.h"
 
 #undef LOG
 #define LOG(args...) FM_LOG("FMRadio", args)
@@ -101,17 +100,16 @@ private:
   FMRadioRequestArgs::Type mType;
   nsWeakPtr mFMRadio;
 };
 
 NS_IMPL_ISUPPORTS_INHERITED0(FMRadioRequest, DOMRequest)
 
 FMRadio::FMRadio()
   : mHeadphoneState(SWITCH_STATE_OFF)
-  , mRdsGroupMask(0)
   , mAudioChannelAgentEnabled(false)
   , mHasInternalAntenna(false)
   , mIsShutdown(false)
 {
   LOG("FMRadio is initialized.");
 
   SetIsDOMBinding();
 }
@@ -217,57 +215,29 @@ FMRadio::Notify(const FMRadioEventType& 
         if (mAudioChannelAgentEnabled) {
           mAudioChannelAgent->StopPlaying();
           mAudioChannelAgentEnabled = false;
         }
 
         DispatchTrustedEvent(NS_LITERAL_STRING("disabled"));
       }
       break;
-    case RDSEnabledChanged:
-      if (RdsEnabled()) {
-        DispatchTrustedEvent(NS_LITERAL_STRING("rdsenabled"));
-      } else {
-        DispatchTrustedEvent(NS_LITERAL_STRING("rdsdisabled"));
-      }
-      break;
-    case PIChanged:
-      DispatchTrustedEvent(NS_LITERAL_STRING("pichange"));
-      break;
-    case PSChanged:
-      DispatchTrustedEvent(NS_LITERAL_STRING("pschange"));
-      break;
-    case RadiotextChanged:
-      DispatchTrustedEvent(NS_LITERAL_STRING("rtchange"));
-      break;
-    case PTYChanged:
-      DispatchTrustedEvent(NS_LITERAL_STRING("ptychange"));
-      break;
-    case NewRDSGroup:
-      DispatchTrustedEvent(NS_LITERAL_STRING("newrdsgroup"));
-      break;
     default:
       MOZ_CRASH();
   }
 }
 
 /* static */
 bool
 FMRadio::Enabled()
 {
   return IFMRadioService::Singleton()->IsEnabled();
 }
 
 bool
-FMRadio::RdsEnabled()
-{
-  return IFMRadioService::Singleton()->IsRDSEnabled();
-}
-
-bool
 FMRadio::AntennaAvailable() const
 {
   return mHasInternalAntenna ? true : (mHeadphoneState != SWITCH_STATE_OFF) &&
     (mHeadphoneState != SWITCH_STATE_UNKNOWN);
 }
 
 Nullable<double>
 FMRadio::GetFrequency() const
@@ -290,79 +260,16 @@ FMRadio::FrequencyLowerBound() const
 }
 
 double
 FMRadio::ChannelWidth() const
 {
   return IFMRadioService::Singleton()->GetChannelWidth();
 }
 
-uint32_t
-FMRadio::RdsGroupMask() const
-{
-  return mRdsGroupMask;
-}
-
-void
-FMRadio::SetRdsGroupMask(uint32_t aRdsGroupMask)
-{
-  mRdsGroupMask = aRdsGroupMask;
-  IFMRadioService::Singleton()->SetRDSGroupMask(aRdsGroupMask);
-}
-
-Nullable<unsigned short>
-FMRadio::GetPi() const
-{
-  return IFMRadioService::Singleton()->GetPi();
-}
-
-Nullable<uint8_t>
-FMRadio::GetPty() const
-{
-  return IFMRadioService::Singleton()->GetPty();
-}
-
-void
-FMRadio::GetPs(DOMString& aPsname) const
-{
-  if (!IFMRadioService::Singleton()->GetPs(aPsname)) {
-    aPsname.SetNull();
-  }
-}
-
-void
-FMRadio::GetRt(DOMString& aRadiotext) const
-{
-  if (!IFMRadioService::Singleton()->GetRt(aRadiotext)) {
-    aRadiotext.SetNull();
-  }
-}
-
-void
-FMRadio::GetRdsgroup(JSContext* cx, JS::MutableHandle<JSObject*> retval)
-{
-  uint64_t group;
-  if (!IFMRadioService::Singleton()->GetRdsgroup(group)) {
-    return;
-  }
-
-  JSObject *rdsgroup = Uint16Array::Create(cx, this, 4);
-  uint16_t *data = JS_GetUint16ArrayData(rdsgroup);
-  data[3] = group & 0xFFFF;
-  group >>= 16;
-  data[2] = group & 0xFFFF;
-  group >>= 16;
-  data[1] = group & 0xFFFF;
-  group >>= 16;
-  data[0] = group & 0xFFFF;
-
-  JS::ExposeObjectToActiveJS(rdsgroup);
-  retval.set(rdsgroup);
-}
-
 already_AddRefed<DOMRequest>
 FMRadio::Enable(double aFrequency)
 {
   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
   if (!win) {
     return nullptr;
   }
 
@@ -438,42 +345,16 @@ FMRadio::CancelSeek()
   }
 
   nsRefPtr<FMRadioRequest> r = new FMRadioRequest(win, this);
   IFMRadioService::Singleton()->CancelSeek(r);
 
   return r.forget();
 }
 
-already_AddRefed<DOMRequest>
-FMRadio::EnableRDS()
-{
-  nsCOMPtr<nsPIDOMWindow> win = GetOwner();
-  if (!win) {
-    return nullptr;
-  }
-
-  nsRefPtr<FMRadioRequest> r = new FMRadioRequest(win, this);
-  IFMRadioService::Singleton()->EnableRDS(r);
-  return r.forget();
-}
-
-already_AddRefed<DOMRequest>
-FMRadio::DisableRDS()
-{
-  nsCOMPtr<nsPIDOMWindow> win = GetOwner();
-  if (!win) {
-    return nullptr;
-  }
-
-  nsRefPtr<FMRadioRequest> r = new FMRadioRequest(win, this);
-  FMRadioService::Singleton()->DisableRDS(r);
-  return r.forget();
-}
-
 NS_IMETHODIMP
 FMRadio::HandleEvent(nsIDOMEvent* aEvent)
 {
   nsAutoString type;
   aEvent->GetType(type);
 
   if (!type.EqualsLiteral("visibilitychange")) {
     return NS_ERROR_FAILURE;
--- a/dom/fmradio/FMRadio.h
+++ b/dom/fmradio/FMRadio.h
@@ -50,81 +50,53 @@ public:
   {
     return GetOwner();
   }
 
   virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
 
   static bool Enabled();
 
-  bool RdsEnabled();
-
   bool AntennaAvailable() const;
 
   Nullable<double> GetFrequency() const;
 
   double FrequencyUpperBound() const;
 
   double FrequencyLowerBound() const;
 
   double ChannelWidth() const;
 
-  uint32_t RdsGroupMask() const;
-
-  void SetRdsGroupMask(uint32_t aRdsGroupMask);
-
-  Nullable<unsigned short> GetPi() const;
-
-  Nullable<uint8_t> GetPty() const;
-
-  void GetPs(DOMString& aPsname) const;
-
-  void GetRt(DOMString& aRadiotext) const;
-
-  void GetRdsgroup(JSContext* cx, JS::MutableHandle<JSObject*> retval);
-
   already_AddRefed<DOMRequest> Enable(double aFrequency);
 
   already_AddRefed<DOMRequest> Disable();
 
   already_AddRefed<DOMRequest> SetFrequency(double aFrequency);
 
   already_AddRefed<DOMRequest> SeekUp();
 
   already_AddRefed<DOMRequest> SeekDown();
 
   already_AddRefed<DOMRequest> CancelSeek();
 
-  already_AddRefed<DOMRequest> EnableRDS();
-
-  already_AddRefed<DOMRequest> DisableRDS();
-
   IMPL_EVENT_HANDLER(enabled);
   IMPL_EVENT_HANDLER(disabled);
-  IMPL_EVENT_HANDLER(rdsenabled);
-  IMPL_EVENT_HANDLER(rdsdisabled);
   IMPL_EVENT_HANDLER(antennaavailablechange);
   IMPL_EVENT_HANDLER(frequencychange);
-  IMPL_EVENT_HANDLER(pichange);
-  IMPL_EVENT_HANDLER(ptychange);
-  IMPL_EVENT_HANDLER(pschange);
-  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;
-  uint32_t mRdsGroupMask;
   bool mAudioChannelAgentEnabled;
   bool mHasInternalAntenna;
   bool mIsShutdown;
 
   nsCOMPtr<nsIAudioChannelAgent> mAudioChannelAgent;
 };
 
 END_FMRADIO_NAMESPACE
--- a/dom/fmradio/FMRadioCommon.h
+++ b/dom/fmradio/FMRadioCommon.h
@@ -25,23 +25,17 @@
 #define END_FMRADIO_NAMESPACE \
   } /* namespace dom */ } /* namespace mozilla */
 
 BEGIN_FMRADIO_NAMESPACE
 
 enum FMRadioEventType
 {
   FrequencyChanged,
-  EnabledChanged,
-  RDSEnabledChanged,
-  PIChanged,
-  PSChanged,
-  PTYChanged,
-  RadiotextChanged,
-  NewRDSGroup
+  EnabledChanged
 };
 
 typedef mozilla::Observer<FMRadioEventType>     FMRadioEventObserver;
 typedef mozilla::ObserverList<FMRadioEventType> FMRadioEventObserverList;
 
 END_FMRADIO_NAMESPACE
 
 #endif /* FMRADIOCOMMON_H_ */
--- a/dom/fmradio/FMRadioService.cpp
+++ b/dom/fmradio/FMRadioService.cpp
@@ -21,18 +21,16 @@
 
 #define BAND_87500_108000_kHz 1
 #define BAND_76000_108000_kHz 2
 #define BAND_76000_90000_kHz  3
 
 #define MOZSETTINGS_CHANGED_ID "mozsettings-changed"
 #define SETTING_KEY_AIRPLANEMODE_ENABLED "airplaneMode.enabled"
 
-#define DOM_PARSED_RDS_GROUPS ((0x2 << 30) | (0x3 << 4) | (0x3 << 0))
-
 using namespace mozilla::hal;
 using mozilla::Preferences;
 
 BEGIN_FMRADIO_NAMESPACE
 
 // static
 IFMRadioService*
 IFMRadioService::Singleton()
@@ -46,36 +44,19 @@ IFMRadioService::Singleton()
 
 StaticRefPtr<FMRadioService> FMRadioService::sFMRadioService;
 
 FMRadioService::FMRadioService()
   : mPendingFrequencyInKHz(0)
   , mState(Disabled)
   , mHasReadAirplaneModeSetting(false)
   , mAirplaneModeEnabled(false)
-  , mRDSEnabled(false)
   , mPendingRequest(nullptr)
   , mObserverList(FMRadioEventObserverList())
-  , mRDSGroupMask(0)
-  , mLastPI(0)
-  , mPI(0)
-  , mPTY(0)
-  , mPISet(false)
-  , mPTYSet(false)
-  , mRDSLock("FMRadioService::mRDSLock")
-  , mPSNameState(0)
-  , mRadiotextAB(false)
-  , mRDSGroupSet(false)
-  , mPSNameSet(false)
-  , mRadiotextSet(false)
 {
-  memset(mPSName, 0, sizeof(mPSName));
-  memset(mRadiotext, 0, sizeof(mRadiotext));
-  memset(mTempPSName, 0, sizeof(mTempPSName));
-  memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
 
   // Read power state and frequency from Hal.
   mEnabled = IsFMRadioOn();
   if (mEnabled) {
     mPendingFrequencyInKHz = GetFMRadioFrequency();
     SetState(Enabled);
   }
 
@@ -124,22 +105,20 @@ FMRadioService::FMRadioService()
 
   if (obs && NS_FAILED(obs->AddObserver(this,
                                         MOZSETTINGS_CHANGED_ID,
                                         /* useWeak */ false))) {
     NS_WARNING("Failed to add settings change observer!");
   }
 
   RegisterFMRadioObserver(this);
-  RegisterFMRadioRDSObserver(this);
 }
 
 FMRadioService::~FMRadioService()
 {
-  UnregisterFMRadioRDSObserver(this);
   UnregisterFMRadioObserver(this);
 }
 
 class EnableRunnable MOZ_FINAL : public nsRunnable
 {
 public:
   EnableRunnable(uint32_t aUpperLimit, uint32_t aLowerLimit, uint32_t aSpaceType, uint32_t aPreemphasis)
     : mUpperLimit(aUpperLimit)
@@ -293,31 +272,16 @@ public:
 
     return NS_OK;
   }
 
 private:
   FMRadioSeekDirection mDirection;
 };
 
-class NotifyRunnable MOZ_FINAL : public nsRunnable
-{
-public:
-  NotifyRunnable(FMRadioEventType aType) : mType(aType) { }
-
-  NS_IMETHOD Run()
-  {
-    FMRadioService::Singleton()->NotifyFMRadioEvent(mType);
-    return NS_OK;
-  }
-
-private:
-  FMRadioEventType mType;
-};
-
 void
 FMRadioService::TransitionState(const FMRadioResponseType& aResponse,
                                 FMRadioState aState)
 {
   if (mPendingRequest) {
     mPendingRequest->SetReply(aResponse);
     NS_DispatchToMainThread(mPendingRequest);
   }
@@ -405,23 +369,16 @@ FMRadioService::RoundFrequency(double aF
 
 bool
 FMRadioService::IsEnabled() const
 {
   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
   return IsFMRadioOn();
 }
 
-bool
-FMRadioService::IsRDSEnabled() const
-{
-  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
-  return mRDSEnabled;
-}
-
 double
 FMRadioService::GetFrequency() const
 {
   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
   if (IsEnabled()) {
     int32_t frequencyInKHz = GetFMRadioFrequency();
     return frequencyInKHz / 1000.0;
   }
@@ -445,64 +402,16 @@ FMRadioService::GetFrequencyLowerBound()
 
 double
 FMRadioService::GetChannelWidth() const
 {
   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
   return mChannelWidthInKHz / 1000.0;
 }
 
-Nullable<unsigned short>
-FMRadioService::GetPi() const
-{
-  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
-  if (!mPISet) {
-    return Nullable<unsigned short>();
-  }
-  return Nullable<unsigned short>(mPI);
-}
-
-Nullable<uint8_t>
-FMRadioService::GetPty() const
-{
-  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
-  if (!mPTYSet) {
-    return Nullable<uint8_t>();
-  }
-  return Nullable<uint8_t>(mPTY);
-}
-
-bool
-FMRadioService::GetPs(nsString& aPSName)
-{
-  MutexAutoLock lock(mRDSLock);
-  if (mPSNameSet) {
-    aPSName = nsString(mPSName);
-  }
-  return mPSNameSet;
-}
-
-bool
-FMRadioService::GetRt(nsString& aRadiotext)
-{
-  MutexAutoLock lock(mRDSLock);
-  if (mRadiotextSet) {
-    aRadiotext = nsString(mRadiotext);
-  }
-  return mRadiotextSet;
-}
-
-bool
-FMRadioService::GetRdsgroup(uint64_t& aRDSGroup)
-{
-  MutexAutoLock lock(mRDSLock);
-  aRDSGroup = mRDSGroup;
-  return mRDSGroupSet;
-}
-
 void
 FMRadioService::Enable(double aFrequencyInMHz,
                        FMRadioReplyRunnable* aReplyRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
   MOZ_ASSERT(aReplyRunnable);
 
   switch (mState) {
@@ -765,57 +674,16 @@ FMRadioService::CancelSeek(FMRadioReplyR
 
   TransitionState(
     ErrorResponse(NS_LITERAL_STRING("Seek action is cancelled")), Enabled);
 
   aReplyRunnable->SetReply(SuccessResponse());
   NS_DispatchToMainThread(aReplyRunnable);
 }
 
-void
-FMRadioService::SetRDSGroupMask(uint32_t aRDSGroupMask)
-{
-  mRDSGroupMask = aRDSGroupMask;
-  if (IsFMRadioOn()) {
-    hal::EnableRDS(mRDSGroupMask | DOM_PARSED_RDS_GROUPS);
-  }
-}
-
-void
-FMRadioService::EnableRDS(FMRadioReplyRunnable* aReplyRunnable)
-{
-  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
-  MOZ_ASSERT(aReplyRunnable);
-
-  mRDSEnabled = true;
-  if (IsFMRadioOn()) {
-    hal::EnableRDS(mRDSGroupMask | DOM_PARSED_RDS_GROUPS);
-  }
-
-  aReplyRunnable->SetReply(SuccessResponse());
-  NS_DispatchToMainThread(aReplyRunnable);
-  NS_DispatchToMainThread(new NotifyRunnable(RDSEnabledChanged));
-}
-
-void
-FMRadioService::DisableRDS(FMRadioReplyRunnable* aReplyRunnable)
-{
-  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
-  MOZ_ASSERT(aReplyRunnable);
-
-  mRDSEnabled = false;
-  if (IsFMRadioOn()) {
-    hal::DisableRDS();
-  }
-
-  aReplyRunnable->SetReply(SuccessResponse());
-  NS_DispatchToMainThread(aReplyRunnable);
-  NS_DispatchToMainThread(new NotifyRunnable(RDSEnabledChanged));
-}
-
 NS_IMETHODIMP
 FMRadioService::Observe(nsISupports* aSubject,
                         const char* aTopic,
                         const char16_t* aData)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(sFMRadioService);
 
@@ -887,28 +755,20 @@ FMRadioService::Notify(const FMRadioOper
       // event, to make sure the FM app will get the right frequency when the
       // `EnabledChange` event is sent.
       mPendingFrequencyInKHz = GetFMRadioFrequency();
       UpdatePowerState();
 
       // The frequency was changed from '0' to some meaningful number, so we
       // should send the `FrequencyChanged` event manually.
       NotifyFMRadioEvent(FrequencyChanged);
-
-      if (mRDSEnabled) {
-        hal::EnableRDS(mRDSGroupMask | DOM_PARSED_RDS_GROUPS);
-      }
       break;
     case FM_RADIO_OPERATION_DISABLE:
       MOZ_ASSERT(mState == Disabling);
 
-      mPISet = false;
-      mPTYSet = false;
-      memset(mPSName, 0, sizeof(mPSName));
-      memset(mRadiotext, 0, sizeof(mRadiotext));
       TransitionState(SuccessResponse(), Disabled);
       UpdatePowerState();
       break;
     case FM_RADIO_OPERATION_SEEK:
 
       // Seek action might be cancelled by SetFrequency(), we need to check if
       // the current state is Seeking.
       if (mState == Seeking) {
@@ -920,284 +780,16 @@ FMRadioService::Notify(const FMRadioOper
     case FM_RADIO_OPERATION_TUNE:
       UpdateFrequency();
       break;
     default:
       MOZ_CRASH();
   }
 }
 
-/* This is defined by the RDS standard */
-static const uint16_t sRDSToUnicodeMap[256] = {
-  // The lower half differs from ASCII in 0x1F, 0x24, 0x5E, 0x7E
-  // Most control characters are replaced with 0x20 (space)
-  // 0x0-
-  0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
-  0x0020, 0x0009, 0x000A, 0x000B, 0x0020, 0x00D0, 0x0020, 0x0020,
-
-  // 0x1-
-  0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
-  0x0020, 0x0020, 0x0020, 0x001B, 0x0020, 0x0020, 0x0020, 0x00AD,
-
-  // 0x2-
-  0x0020, 0x0021, 0x0022, 0x0023, 0x00A4, 0x0025, 0x0026, 0x0027,
-  0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
-
-  // 0x3-
-  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
-  0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
-
-  // 0x4-
-  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
-  0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
-
-  // 0x5-
-  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
-  0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x2015, 0x005F,
-
-  // 0x6-
-  0x2551, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
-  0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
-
-  // 0x7-
-  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
-  0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x00AF, 0x007F,
-
-  // 0x8-
-  0x00E1, 0x00E0, 0x00E9, 0x00E8, 0x00ED, 0x00EC, 0x00F3, 0x00F2,
-  0x00FA, 0x00F9, 0x00D1, 0x00C7, 0x015E, 0x00DF, 0x00A1, 0x0132,
-
-  // 0x9-
-  0x00E2, 0x00E4, 0x00EA, 0x00EB, 0x00EE, 0x00EF, 0x00F4, 0x00F6,
-  0x00FB, 0x00FC, 0x00F1, 0x00E7, 0x015F, 0x011F, 0x0131, 0x0133,
-
-  // 0xA-
-  0x00AA, 0x03B1, 0x00A9, 0x2030, 0x011E, 0x011B, 0x0148, 0x0151,
-  0x03C0, 0x20AC, 0x00A3, 0x0024, 0x2190, 0x2191, 0x2192, 0x2193,
-
-  // 0xB-
-  0x00BA, 0x00B9, 0x00B2, 0x00B3, 0x00B1, 0x0130, 0x0144, 0x0171,
-  0x03BC, 0x00BF, 0x00F7, 0x00B0, 0x00BC, 0x00BD, 0x00BE, 0x00A7,
-
-  // 0xC-
-  0x00C1, 0x00C0, 0x00C9, 0x00C8, 0x00CD, 0x00CC, 0x00D3, 0x00D2,
-  0x00DA, 0x00D9, 0x0158, 0x010C, 0x0160, 0x017D, 0x00D0, 0x013F,
-
-  // 0xD-
-  0x00C2, 0x00C4, 0x00CA, 0x00CB, 0x00CE, 0x00CF, 0x00D4, 0x00D6,
-  0x00DB, 0x00DC, 0x0159, 0x010D, 0x0161, 0x017E, 0x0111, 0x0140,
-
-  // 0xE-
-  0x00C3, 0x00C5, 0x00C6, 0x0152, 0x0177, 0x00DD, 0x00D5, 0x00D8,
-  0x00DE, 0x014A, 0x0154, 0x0106, 0x015A, 0x0179, 0x0166, 0x00F0,
-
-  // 0xF-
-  0x00E3, 0x00E5, 0x00E6, 0x0153, 0x0175, 0x00FD, 0x00F5, 0x00F8,
-  0x00FE, 0x014B, 0x0155, 0x0107, 0x015B, 0x017A, 0x0167, 0x0020,
-};
-
-void
-FMRadioService::Notify(const FMRadioRDSGroup& aRDSGroup)
-{
-  uint16_t blocks[4];
-  blocks[0] = aRDSGroup.blockA();
-  blocks[1] = aRDSGroup.blockB();
-  blocks[2] = aRDSGroup.blockC();
-  blocks[3] = aRDSGroup.blockD();
-
-  /* Bit 11 in block B determines whether this is a type B group. */
-  uint16_t lastPI = blocks[1] & (1 << 11) ? blocks[2] : mLastPI;
-
-  /* Update PI if it's not set or if we get two PI with the new value. */
-  if ((mPI != blocks[0] && lastPI == blocks[0]) || !mPISet) {
-    mPI = blocks[0];
-    if (!mPISet) {
-      mPSNameState = 0;
-      mRadiotextState = 0;
-      memset(mTempPSName, 0, sizeof(mTempPSName));
-      memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
-    }
-    mPISet = true;
-    NS_DispatchToMainThread(new NotifyRunnable(PIChanged));
-  }
-  mLastPI = blocks[0];
-
-  /* PTY is also updated using the same logic as PI */
-  uint16_t pty = (blocks[1] >> 5) & 0x1F;
-  if ((mPTY != pty && pty == mLastPTY) || !mPTYSet) {
-    mPTY = pty;
-    mPTYSet = true;
-    NS_DispatchToMainThread(new NotifyRunnable(PTYChanged));
-  }
-  mLastPTY = pty;
-
-  uint16_t grouptype = blocks[1] >> 11;
-  switch (grouptype) {
-    case 0: // 0a
-    case 1: // 0b
-    {
-      uint16_t segmentAddr = (blocks[1] & 0x3);
-      // mPSNameState is a bitmask that lets us ensure all segments
-      // are received before updating the PS name.
-      if (!segmentAddr) {
-        mPSNameState = 1;
-      } else {
-        mPSNameState |= 1 << segmentAddr;
-      }
-
-      uint16_t offset = segmentAddr << 1;
-      mTempPSName[offset] = sRDSToUnicodeMap[blocks[3] >> 8];
-      mTempPSName[offset + 1] = sRDSToUnicodeMap[blocks[3] & 0xFF];
-
-      if (mPSNameState != 0xF) {
-        break;
-      }
-
-      mPSNameState = 0;
-      if (memcmp(mTempPSName, mPSName, sizeof(mTempPSName))) {
-        MutexAutoLock lock(mRDSLock);
-        mPSNameSet = true;
-        memcpy(mPSName, mTempPSName, sizeof(mTempPSName));
-        NS_DispatchToMainThread(new NotifyRunnable(PSChanged));
-      }
-      break;
-    }
-    case 4: // 2a Radiotext
-    {
-      uint16_t segmentAddr = (blocks[1] & 0xF);
-      bool textAB = blocks[1] & (1 << 5);
-      if (textAB != mRadiotextAB) {
-        mRadiotextState = 0;
-        memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
-        mRadiotextAB = textAB;
-        MutexAutoLock lock(mRDSLock);
-        memset(mRadiotext, 0, sizeof(mRadiotext));
-        NS_DispatchToMainThread(new NotifyRunnable(RadiotextChanged));
-      }
-
-      // mRadiotextState is a bitmask that lets us ensure all segments
-      // are received before updating the radiotext.
-      if (!segmentAddr) {
-        mRadiotextState = 1;
-      } else {
-        mRadiotextState |= 1 << segmentAddr;
-      }
-
-      uint8_t segment[4];
-      segment[0] = blocks[2] >> 8;
-      segment[1] = blocks[2] & 0xFF;
-      segment[2] = blocks[3] >> 8;
-      segment[3] = blocks[3] & 0xFF;
-
-      uint16_t offset = segmentAddr << 2;
-      bool done = false;
-      for (int i = 0; i < 4; i++) {
-        if (segment[i] == '\r') {
-          mTempRadiotext[offset++] = 0;
-          done = true;
-        } else {
-          mTempRadiotext[offset++] = sRDSToUnicodeMap[segment[i]];
-        }
-      }
-      if (offset == 64) {
-        done = true;
-      }
-
-      if (!done ||
-          (mRadiotextState + 1) != (1 << ((blocks[1] & 0xF) + 1)) ||
-          !memcmp(mTempRadiotext, mRadiotext, sizeof(mTempRadiotext))) {
-        break;
-      }
-
-      MutexAutoLock lock(mRDSLock);
-      mRadiotextSet = true;
-      memcpy(mRadiotext, mTempRadiotext, sizeof(mTempRadiotext));
-      NS_DispatchToMainThread(new NotifyRunnable(RadiotextChanged));
-      break;
-    }
-    case 5: // 2b Radiotext
-    {
-      uint16_t segmentAddr = (blocks[1] & 0xF);
-      bool textAB = blocks[1] & (1 << 5);
-      if (textAB != mRadiotextAB) {
-        mRadiotextState = 0;
-        memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
-        mRadiotextAB = textAB;
-        MutexAutoLock lock(mRDSLock);
-        memset(mRadiotext, 0, sizeof(mRadiotext));
-        NS_DispatchToMainThread(new NotifyRunnable(RadiotextChanged));
-      }
-
-      if (!segmentAddr) {
-        mRadiotextState = 1;
-      } else {
-        mRadiotextState |= 1 << segmentAddr;
-      }
-      uint8_t segment[2];
-      segment[0] = blocks[3] >> 8;
-      segment[1] = blocks[3] & 0xFF;
-
-      uint16_t offset = segmentAddr << 1;
-      bool done = false;
-      for (int i = 0; i < 2; i++) {
-        if (segment[i] == '\r') {
-          mTempRadiotext[offset++] = 0;
-          done = true;
-        } else {
-          mTempRadiotext[offset++] = sRDSToUnicodeMap[segment[i]];
-        }
-      }
-      if (offset == 32) {
-        done = true;
-      }
-
-      if (!done ||
-          (mRadiotextState + 1) != (1 << ((blocks[1] & 0xF) + 1)) ||
-          !memcmp(mTempRadiotext, mRadiotext, sizeof(mTempRadiotext))) {
-        break;
-      }
-
-      MutexAutoLock lock(mRDSLock);
-      mRadiotextSet = true;
-      memcpy(mRadiotext, mTempRadiotext, sizeof(mTempRadiotext));
-      NS_DispatchToMainThread(new NotifyRunnable(RadiotextChanged));
-      break;
-    }
-    case 31: // 15b Fast Tuning and Switching
-    {
-      uint16_t secondPty = (blocks[3] >> 5) & 0x1F;
-      if (pty == mPTY || pty != secondPty) {
-        break;
-      }
-      mPTY = pty;
-      NS_DispatchToMainThread(new NotifyRunnable(PTYChanged));
-      break;
-    }
-  }
-
-  // Only notify users of raw RDS groups that they're interested in.
-  // We always receive DOM_PARSED_RDS_GROUPS when RDS is enabled.
-  if (!(mRDSGroupMask & (1 << grouptype))) {
-    return;
-  }
-
-  uint64_t newgroup = blocks[0];
-  newgroup <<= 16;
-  newgroup |= blocks[1];
-  newgroup <<= 16;
-  newgroup |= blocks[2];
-  newgroup <<= 16;
-  newgroup |= blocks[3];
-
-  MutexAutoLock lock(mRDSLock);
-  mRDSGroup = newgroup;
-  mRDSGroupSet = true;
-  NS_DispatchToMainThread(new NotifyRunnable(NewRDSGroup));
-}
-
 void
 FMRadioService::UpdatePowerState()
 {
   bool enabled = IsFMRadioOn();
   if (enabled != mEnabled) {
     mEnabled = enabled;
     NotifyFMRadioEvent(EnabledChanged);
   }
@@ -1205,23 +797,16 @@ FMRadioService::UpdatePowerState()
 
 void
 FMRadioService::UpdateFrequency()
 {
   int32_t frequency = GetFMRadioFrequency();
   if (mPendingFrequencyInKHz != frequency) {
     mPendingFrequencyInKHz = frequency;
     NotifyFMRadioEvent(FrequencyChanged);
-    mPISet = false;
-    mPTYSet = false;
-    memset(mPSName, 0, sizeof(mPSName));
-    memset(mRadiotext, 0, sizeof(mRadiotext));
-    mRDSGroupSet = false;
-    mPSNameSet = false;
-    mRadiotextSet = false;
   }
 }
 
 // static
 FMRadioService*
 FMRadioService::Singleton()
 {
   MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
--- a/dom/fmradio/FMRadioService.h
+++ b/dom/fmradio/FMRadioService.h
@@ -2,21 +2,19 @@
 /* vim: set ts=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_fmradioservice_h__
 #define mozilla_dom_fmradioservice_h__
 
-#include "mozilla/dom/Nullable.h"
 #include "mozilla/dom/PFMRadioRequest.h"
 #include "FMRadioCommon.h"
 #include "mozilla/Hal.h"
-#include "mozilla/Mutex.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/Services.h"
 #include "nsThreadUtils.h"
 #include "nsIObserver.h"
 #include "nsXULAppAPI.h"
 
 BEGIN_FMRADIO_NAMESPACE
 
@@ -92,36 +90,27 @@ protected:
  */
 class IFMRadioService
 {
 protected:
   virtual ~IFMRadioService() { }
 
 public:
   virtual bool IsEnabled() const = 0;
-  virtual bool IsRDSEnabled() const = 0;
   virtual double GetFrequency() const = 0;
   virtual double GetFrequencyUpperBound() const = 0;
   virtual double GetFrequencyLowerBound() const = 0;
   virtual double GetChannelWidth() const = 0;
-  virtual Nullable<unsigned short> GetPi() const = 0;
-  virtual Nullable<uint8_t> GetPty() const = 0;
-  virtual bool GetPs(nsString& aPsname) = 0;
-  virtual bool GetRt(nsString& aRadiotext) = 0;
-  virtual bool GetRdsgroup(uint64_t& aRDSGroup) = 0;
 
   virtual void Enable(double aFrequency, FMRadioReplyRunnable* aReplyRunnable) = 0;
   virtual void Disable(FMRadioReplyRunnable* aReplyRunnable) = 0;
   virtual void SetFrequency(double aFrequency, FMRadioReplyRunnable* aReplyRunnable) = 0;
   virtual void Seek(mozilla::hal::FMRadioSeekDirection aDirection,
                     FMRadioReplyRunnable* aReplyRunnable) = 0;
   virtual void CancelSeek(FMRadioReplyRunnable* aReplyRunnable) = 0;
-  virtual void SetRDSGroupMask(uint32_t aRDSGroupMask) = 0;
-  virtual void EnableRDS(FMRadioReplyRunnable* aReplyRunnable) = 0;
-  virtual void DisableRDS(FMRadioReplyRunnable* aReplyRunnable) = 0;
 
   /**
    * Register handler to receive the FM Radio events, including:
    *   - StateChangedEvent
    *   - FrequencyChangedEvent
    *
    * Called by FMRadio and FMRadioParent.
    */
@@ -144,63 +133,50 @@ enum FMRadioState
   Disabling,
   Enabling,
   Enabled,
   Seeking
 };
 
 class FMRadioService MOZ_FINAL : public IFMRadioService
                                , public hal::FMRadioObserver
-                               , public hal::FMRadioRDSObserver
                                , public nsIObserver
 {
   friend class ReadAirplaneModeSettingTask;
   friend class EnableRunnable;
   friend class DisableRunnable;
-  friend class NotifyRunnable;
 
 public:
   static FMRadioService* Singleton();
   virtual ~FMRadioService();
 
   NS_DECL_ISUPPORTS
 
   virtual bool IsEnabled() const MOZ_OVERRIDE;
-  virtual bool IsRDSEnabled() const MOZ_OVERRIDE;
   virtual double GetFrequency() const MOZ_OVERRIDE;
   virtual double GetFrequencyUpperBound() const MOZ_OVERRIDE;
   virtual double GetFrequencyLowerBound() const MOZ_OVERRIDE;
   virtual double GetChannelWidth() const MOZ_OVERRIDE;
-  virtual Nullable<unsigned short> GetPi() const MOZ_OVERRIDE;
-  virtual Nullable<uint8_t> GetPty() const MOZ_OVERRIDE;
-  virtual bool GetPs(nsString& aPsname) MOZ_OVERRIDE;
-  virtual bool GetRt(nsString& aRadiotext) MOZ_OVERRIDE;
-  virtual bool GetRdsgroup(uint64_t& aRDSGroup) MOZ_OVERRIDE;
 
   virtual void Enable(double aFrequency,
                       FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void Disable(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void SetFrequency(double aFrequency,
                             FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void Seek(mozilla::hal::FMRadioSeekDirection aDirection,
                     FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void CancelSeek(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
-  virtual void SetRDSGroupMask(uint32_t aRDSGroupMask) MOZ_OVERRIDE;
-  virtual void EnableRDS(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
-  virtual void DisableRDS(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
 
   virtual void AddObserver(FMRadioEventObserver* aObserver) MOZ_OVERRIDE;
   virtual void RemoveObserver(FMRadioEventObserver* aObserver) MOZ_OVERRIDE;
 
   virtual void EnableAudio(bool aAudioEnabled) MOZ_OVERRIDE;
 
   /* FMRadioObserver */
   void Notify(const hal::FMRadioOperationInformation& aInfo) MOZ_OVERRIDE;
-  /* FMRadioRDSObserver */
-  void Notify(const hal::FMRadioRDSGroup& aRDSGroup) MOZ_OVERRIDE;
 
   NS_DECL_NSIOBSERVER
 
 protected:
   FMRadioService();
 
 private:
   int32_t RoundFrequency(double aFrequencyInMHz);
@@ -216,51 +192,26 @@ private:
   bool mEnabled;
 
   int32_t mPendingFrequencyInKHz;
 
   FMRadioState mState;
 
   bool mHasReadAirplaneModeSetting;
   bool mAirplaneModeEnabled;
-  bool mRDSEnabled;
 
   uint32_t mUpperBoundInKHz;
   uint32_t mLowerBoundInKHz;
   uint32_t mChannelWidthInKHz;
   uint32_t mPreemphasis;
 
   nsCOMPtr<nsIThread> mTuneThread;
   nsRefPtr<FMRadioReplyRunnable> mPendingRequest;
 
   FMRadioEventObserverList mObserverList;
 
   static StaticRefPtr<FMRadioService> sFMRadioService;
-
-  uint32_t mRDSGroupMask;
-
-  uint16_t mLastPI;
-  uint16_t mLastPTY;
-  Atomic<uint32_t> mPI;
-  Atomic<uint32_t> mPTY;
-  Atomic<bool> mPISet;
-  Atomic<bool> mPTYSet;
-
-  /* Protects mPSName, mRadiotext, and mRDSGroup */
-  Mutex mRDSLock;
-  char16_t mPSName[9];
-  char16_t mRadiotext[65];
-  uint64_t mRDSGroup;
-
-  uint8_t mPSNameState;
-  uint16_t mRadiotextState;
-  uint16_t mTempPSName[8];
-  uint16_t mTempRadiotext[64];
-  bool mRadiotextAB;
-  bool mRDSGroupSet;
-  bool mPSNameSet;
-  bool mRadiotextSet;
 };
 
 END_FMRADIO_NAMESPACE
 
 #endif // mozilla_dom_fmradioservice_h__
 
--- a/dom/fmradio/ipc/FMRadioChild.cpp
+++ b/dom/fmradio/ipc/FMRadioChild.cpp
@@ -11,23 +11,17 @@
 using namespace mozilla::hal;
 
 BEGIN_FMRADIO_NAMESPACE
 
 StaticAutoPtr<FMRadioChild> FMRadioChild::sFMRadioChild;
 
 FMRadioChild::FMRadioChild()
   : mEnabled(false)
-  , mRDSEnabled(false)
-  , mRDSGroupSet(false)
-  , mPSNameSet(false)
-  , mRadiotextSet(false)
   , mFrequency(0)
-  , mRDSGroup(0)
-  , mRDSGroupMask(0)
   , mObserverList(FMRadioEventObserverList())
 {
   MOZ_COUNT_CTOR(FMRadioChild);
 
   ContentChild::GetSingleton()->SendPFMRadioConstructor(this);
 
   StatusInfo statusInfo;
   SendGetStatusInfo(&statusInfo);
@@ -45,22 +39,16 @@ FMRadioChild::~FMRadioChild()
 }
 
 bool
 FMRadioChild::IsEnabled() const
 {
   return mEnabled;
 }
 
-bool
-FMRadioChild::IsRDSEnabled() const
-{
-  return mRDSEnabled;
-}
-
 double
 FMRadioChild::GetFrequency() const
 {
   return mFrequency;
 }
 
 
 double
@@ -76,53 +64,16 @@ FMRadioChild::GetFrequencyLowerBound() c
 }
 
 double
 FMRadioChild::GetChannelWidth() const
 {
   return mChannelWidth;
 }
 
-Nullable<unsigned short>
-FMRadioChild::GetPi() const
-{
-  return mPI;
-}
-
-Nullable<uint8_t>
-FMRadioChild::GetPty() const
-{
-  return mPTY;
-}
-
-bool
-FMRadioChild::GetPs(nsString& aPSName)
-{
-  if (mPSNameSet) {
-    aPSName = mPSName;
-  }
-  return mPSNameSet;
-}
-
-bool
-FMRadioChild::GetRt(nsString& aRadiotext)
-{
-  if (mRadiotextSet) {
-    aRadiotext = mRadiotext;
-  }
-  return mRadiotextSet;
-}
-
-bool
-FMRadioChild::GetRdsgroup(uint64_t& aRDSGroup)
-{
-  aRDSGroup = mRDSGroup;
-  return mRDSGroupSet;
-}
-
 void
 FMRadioChild::Enable(double aFrequency, FMRadioReplyRunnable* aReplyRunnable)
 {
   SendRequest(aReplyRunnable, EnableRequestArgs(aFrequency));
 }
 
 void
 FMRadioChild::Disable(FMRadioReplyRunnable* aReplyRunnable)
@@ -145,35 +96,16 @@ FMRadioChild::Seek(FMRadioSeekDirection 
 }
 
 void
 FMRadioChild::CancelSeek(FMRadioReplyRunnable* aReplyRunnable)
 {
   SendRequest(aReplyRunnable, CancelSeekRequestArgs());
 }
 
-void
-FMRadioChild::SetRDSGroupMask(uint32_t aRDSGroupMask)
-{
-  mRDSGroupMask = aRDSGroupMask;
-  SendSetRDSGroupMask(aRDSGroupMask);
-}
-
-void
-FMRadioChild::EnableRDS(FMRadioReplyRunnable* aReplyRunnable)
-{
-  SendRequest(aReplyRunnable, EnableRDSArgs());
-}
-
-void
-FMRadioChild::DisableRDS(FMRadioReplyRunnable* aReplyRunnable)
-{
-  SendRequest(aReplyRunnable, DisableRDSArgs());
-}
-
 inline void
 FMRadioChild::NotifyFMRadioEvent(FMRadioEventType aType)
 {
   mObserverList.Broadcast(aType);
 }
 
 void
 FMRadioChild::AddObserver(FMRadioEventObserver* aObserver)
@@ -195,125 +127,30 @@ FMRadioChild::SendRequest(FMRadioReplyRu
   SendPFMRadioRequestConstructor(childRequest, aArgs);
 }
 
 bool
 FMRadioChild::RecvNotifyFrequencyChanged(const double& aFrequency)
 {
   mFrequency = aFrequency;
   NotifyFMRadioEvent(FrequencyChanged);
-
-  if (!mPI.IsNull()) {
-    mPI.SetNull();
-    NotifyFMRadioEvent(PIChanged);
-  }
-  if (!mPTY.IsNull()) {
-    mPTY.SetNull();
-    NotifyFMRadioEvent(PTYChanged);
-  }
-  if (mPSNameSet) {
-    mPSNameSet = false;
-    mPSName.Truncate();
-    NotifyFMRadioEvent(PSChanged);
-  }
-  if (mRadiotextSet) {
-    mRadiotextSet = false;
-    mRadiotext.Truncate();
-    NotifyFMRadioEvent(RadiotextChanged);
-  }
-  mRDSGroupSet = false;
   return true;
 }
 
 bool
 FMRadioChild::RecvNotifyEnabledChanged(const bool& aEnabled,
                                        const double& aFrequency)
 {
   mEnabled = aEnabled;
   mFrequency = aFrequency;
-  if (!mEnabled) {
-    mPI.SetNull();
-    mPTY.SetNull();
-    mPSName.Truncate();
-    mRadiotext.Truncate();
-    mRDSGroupSet = false;
-    mPSNameSet = false;
-    mRadiotextSet = false;
-  }
   NotifyFMRadioEvent(EnabledChanged);
   return true;
 }
 
 bool
-FMRadioChild::RecvNotifyRDSEnabledChanged(const bool& aEnabled)
-{
-  mRDSEnabled = aEnabled;
-  NotifyFMRadioEvent(RDSEnabledChanged);
-  return true;
-}
-
-bool
-FMRadioChild::RecvNotifyPIChanged(const bool& aValid,
-                                  const uint16_t& aCode)
-{
-  if (aValid) {
-    mPI.SetValue(aCode);
-  } else {
-    mPI.SetNull();
-  }
-  NotifyFMRadioEvent(PIChanged);
-  return true;
-}
-
-bool
-FMRadioChild::RecvNotifyPTYChanged(const bool& aValid,
-                                   const uint8_t& aPTY)
-{
-  if (aValid) {
-    mPTY.SetValue(aPTY);
-  } else {
-    mPTY.SetNull();
-  }
-  NotifyFMRadioEvent(PTYChanged);
-  return true;
-}
-
-bool
-FMRadioChild::RecvNotifyPSChanged(const nsString& aPSName)
-{
-  mPSNameSet = true;
-  mPSName = aPSName;
-  NotifyFMRadioEvent(PSChanged);
-  return true;
-}
-
-bool
-FMRadioChild::RecvNotifyRadiotextChanged(const nsString& aRadiotext)
-{
-  mRadiotextSet = true;
-  mRadiotext = aRadiotext;
-  NotifyFMRadioEvent(RadiotextChanged);
-  return true;
-}
-
-bool
-FMRadioChild::RecvNotifyNewRDSGroup(const uint64_t& aGroup)
-{
-  uint16_t grouptype = (aGroup >> 43) & 0x1F;
-  if (!(mRDSGroupMask & (1 << grouptype))) {
-    return true;
-  }
-
-  mRDSGroupSet = true;
-  mRDSGroup = aGroup;
-  NotifyFMRadioEvent(NewRDSGroup);
-  return true;
-}
-
-bool
 FMRadioChild::Recv__delete__()
 {
   return true;
 }
 
 PFMRadioRequestChild*
 FMRadioChild::AllocPFMRadioRequestChild(const FMRadioRequestArgs& aArgs)
 {
--- a/dom/fmradio/ipc/FMRadioChild.h
+++ b/dom/fmradio/ipc/FMRadioChild.h
@@ -29,38 +29,29 @@ public:
   static FMRadioChild* Singleton();
   ~FMRadioChild();
 
   void SendRequest(FMRadioReplyRunnable* aReplyRunnable,
                    FMRadioRequestArgs aArgs);
 
   /* IFMRadioService */
   virtual bool IsEnabled() const MOZ_OVERRIDE;
-  virtual bool IsRDSEnabled() const MOZ_OVERRIDE;
   virtual double GetFrequency() const MOZ_OVERRIDE;
   virtual double GetFrequencyUpperBound() const MOZ_OVERRIDE;
   virtual double GetFrequencyLowerBound() const MOZ_OVERRIDE;
   virtual double GetChannelWidth() const MOZ_OVERRIDE;
-  virtual Nullable<unsigned short> GetPi() const MOZ_OVERRIDE;
-  virtual Nullable<uint8_t> GetPty() const MOZ_OVERRIDE;
-  virtual bool GetPs(nsString& aPSName) MOZ_OVERRIDE;
-  virtual bool GetRt(nsString& aRadiotext) MOZ_OVERRIDE;
-  virtual bool GetRdsgroup(uint64_t& aRDSGroup) MOZ_OVERRIDE;
 
   virtual void Enable(double aFrequency,
                       FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void Disable(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void SetFrequency(double frequency,
                             FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void Seek(mozilla::hal::FMRadioSeekDirection aDirection,
                     FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
   virtual void CancelSeek(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
-  virtual void SetRDSGroupMask(uint32_t aRDSGroupMask) MOZ_OVERRIDE;
-  virtual void EnableRDS(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
-  virtual void DisableRDS(FMRadioReplyRunnable* aReplyRunnable) MOZ_OVERRIDE;
 
   virtual void AddObserver(FMRadioEventObserver* aObserver) MOZ_OVERRIDE;
   virtual void RemoveObserver(FMRadioEventObserver* aObserver) MOZ_OVERRIDE;
 
   virtual void EnableAudio(bool aAudioEnabled) MOZ_OVERRIDE;
 
   /* PFMRadioChild */
   virtual bool
@@ -68,64 +59,34 @@ public:
 
   virtual bool
   RecvNotifyFrequencyChanged(const double& aFrequency) MOZ_OVERRIDE;
 
   virtual bool
   RecvNotifyEnabledChanged(const bool& aEnabled,
                            const double& aFrequency) MOZ_OVERRIDE;
 
-  virtual bool
-  RecvNotifyRDSEnabledChanged(const bool& aEnabled) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyPIChanged(const bool& aValid,
-                      const uint16_t& aCode) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyPTYChanged(const bool& aValid,
-                       const uint8_t& aPTY) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyPSChanged(const nsString& aPSName) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyRadiotextChanged(const nsString& aRadiotext) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyNewRDSGroup(const uint64_t& aGroup) MOZ_OVERRIDE;
-
   virtual PFMRadioRequestChild*
   AllocPFMRadioRequestChild(const FMRadioRequestArgs& aArgs) MOZ_OVERRIDE;
 
   virtual bool
   DeallocPFMRadioRequestChild(PFMRadioRequestChild* aActor) MOZ_OVERRIDE;
 
 private:
   FMRadioChild();
 
   void Init();
 
   inline void NotifyFMRadioEvent(FMRadioEventType aType);
 
   bool mEnabled;
-  bool mRDSEnabled;
-  bool mRDSGroupSet;
-  bool mPSNameSet;
-  bool mRadiotextSet;
   double mFrequency;
   double mUpperBound;
   double mLowerBound;
   double mChannelWidth;
-  Nullable<unsigned short> mPI;
-  Nullable<uint8_t> mPTY;
-  nsAutoString mPSName;
-  nsAutoString mRadiotext;
-  uint64_t mRDSGroup;
-  uint32_t mRDSGroupMask;
 
   FMRadioEventObserverList mObserverList;
 
 private:
   static StaticAutoPtr<FMRadioChild> sFMRadioChild;
 };
 
 END_FMRADIO_NAMESPACE
--- a/dom/fmradio/ipc/FMRadioParent.cpp
+++ b/dom/fmradio/ipc/FMRadioParent.cpp
@@ -1,17 +1,16 @@
 /* -*- Mode: C++; 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 "FMRadioParent.h"
 #include "mozilla/unused.h"
 #include "mozilla/dom/ContentParent.h"
-#include "mozilla/DebugOnly.h"
 #include "FMRadioRequestParent.h"
 #include "FMRadioService.h"
 
 BEGIN_FMRADIO_NAMESPACE
 
 FMRadioParent::FMRadioParent()
 {
   MOZ_COUNT_CTOR(FMRadioParent);
@@ -65,22 +64,16 @@ FMRadioParent::AllocPFMRadioRequestParen
       break;
     case FMRadioRequestArgs::TSeekRequestArgs:
       IFMRadioService::Singleton()->Seek(
         aArgs.get_SeekRequestArgs().direction(), requestParent);
       break;
     case FMRadioRequestArgs::TCancelSeekRequestArgs:
       IFMRadioService::Singleton()->CancelSeek(requestParent);
       break;
-    case FMRadioRequestArgs::TEnableRDSArgs:
-      IFMRadioService::Singleton()->EnableRDS(requestParent);
-      break;
-    case FMRadioRequestArgs::TDisableRDSArgs:
-      IFMRadioService::Singleton()->DisableRDS(requestParent);
-      break;
     default:
       MOZ_CRASH();
   }
 
   // Balanced in DeallocPFMRadioRequestParent
   return requestParent.forget().take();
 }
 
@@ -100,67 +93,23 @@ FMRadioParent::Notify(const FMRadioEvent
       unused << SendNotifyFrequencyChanged(
         IFMRadioService::Singleton()->GetFrequency());
       break;
     case EnabledChanged:
       unused << SendNotifyEnabledChanged(
         IFMRadioService::Singleton()->IsEnabled(),
         IFMRadioService::Singleton()->GetFrequency());
       break;
-    case RDSEnabledChanged:
-      unused << SendNotifyRDSEnabledChanged(
-        IFMRadioService::Singleton()->IsRDSEnabled());
-      break;
-    case PIChanged: {
-      Nullable<unsigned short> pi =
-        IFMRadioService::Singleton()->GetPi();
-      unused << SendNotifyPIChanged(!pi.IsNull(),
-                                    pi.IsNull() ? 0 : pi.Value());
-      break;
-    }
-    case PTYChanged: {
-      Nullable<uint8_t> pty = IFMRadioService::Singleton()->GetPty();
-      unused << SendNotifyPTYChanged(!pty.IsNull(),
-                                     pty.IsNull() ? 0 : pty.Value());
-      break;
-    }
-    case PSChanged: {
-      nsAutoString psname;
-      IFMRadioService::Singleton()->GetPs(psname);
-      unused << SendNotifyPSChanged(psname);
-      break;
-    }
-    case RadiotextChanged: {
-      nsAutoString radiotext;
-      IFMRadioService::Singleton()->GetRt(radiotext);
-      unused << SendNotifyRadiotextChanged(radiotext);
-      break;
-    }
-    case NewRDSGroup: {
-      uint64_t group;
-      DebugOnly<bool> rdsgroupset =
-        IFMRadioService::Singleton()->GetRdsgroup(group);
-      MOZ_ASSERT(rdsgroupset);
-      unused << SendNotifyNewRDSGroup(group);
-      break;
-    }
     default:
       NS_RUNTIMEABORT("not reached");
       break;
   }
 }
 
 bool
 FMRadioParent::RecvEnableAudio(const bool& aAudioEnabled)
 {
   IFMRadioService::Singleton()->EnableAudio(aAudioEnabled);
   return true;
 }
 
-bool
-FMRadioParent::RecvSetRDSGroupMask(const uint32_t& aRDSGroupMask)
-{
-  IFMRadioService::Singleton()->SetRDSGroupMask(aRDSGroupMask);
-  return true;
-}
-
 END_FMRADIO_NAMESPACE
 
--- a/dom/fmradio/ipc/FMRadioParent.h
+++ b/dom/fmradio/ipc/FMRadioParent.h
@@ -34,17 +34,14 @@ public:
   virtual bool
   DeallocPFMRadioRequestParent(PFMRadioRequestParent* aActor) MOZ_OVERRIDE;
 
   /* FMRadioEventObserver */
   virtual void Notify(const FMRadioEventType& aType) MOZ_OVERRIDE;
 
   virtual bool
   RecvEnableAudio(const bool& aAudioEnabled) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvSetRDSGroupMask(const uint32_t& aRDSGroupMask) MOZ_OVERRIDE;
 };
 
 END_FMRADIO_NAMESPACE
 
 #endif // mozilla_dom_fmradioparent_h__
 
--- a/dom/fmradio/ipc/PFMRadio.ipdl
+++ b/dom/fmradio/ipc/PFMRadio.ipdl
@@ -29,33 +29,23 @@ struct SeekRequestArgs
 {
   FMRadioSeekDirection direction;
 };
 
 struct CancelSeekRequestArgs
 {
 };
 
-struct EnableRDSArgs
-{
-};
-
-struct DisableRDSArgs
-{
-};
-
 union FMRadioRequestArgs
 {
   EnableRequestArgs;
   DisableRequestArgs;
   SetFrequencyRequestArgs;
   SeekRequestArgs;
   CancelSeekRequestArgs;
-  EnableRDSArgs;
-  DisableRDSArgs;
 };
 
 struct StatusInfo
 {
   bool enabled;
   double frequency;
   double upperBound;
   double lowerBound;
@@ -71,40 +61,16 @@ child:
   /**
    * Sent when the frequency is changed.
    */
   NotifyFrequencyChanged(double frequency);
   /**
    * Sent when the power state of FM radio HW is changed.
    */
   NotifyEnabledChanged(bool enabled, double frequency);
-  /**
-   * Sent when RDS is enabled or disabled.
-   */
-  NotifyRDSEnabledChanged(bool enabled);
-  /**
-   * Sent when we have a new PI code.
-   */
-  NotifyPIChanged(bool valid, uint16_t code);
-  /**
-   * Sent when we have a new PTY
-   */
-  NotifyPTYChanged(bool valid, uint8_t pty);
-  /**
-   * Sent when we have a new PS name.
-   */
-  NotifyPSChanged(nsString psname);
-  /**
-   * Sent when we have new radiotext.
-   */
-  NotifyRadiotextChanged(nsString radiotext);
-  /**
-   * Sent when a full RDS group is received.
-   */
-  NotifyNewRDSGroup(uint64_t data);
 
   __delete__();
 
 parent:
   /**
    * Get the current status infomation of FM radio HW synchronously.
    * Sent when the singleton object of FMRadioChild is initialized.
    */
@@ -120,18 +86,13 @@ parent:
    * is more error prone.
    */
   PFMRadioRequest(FMRadioRequestArgs requestType);
 
   /**
    * Enable/Disable audio
    */
   EnableAudio(bool audioEnabled);
-
-  /**
-   * Set RDS group mask
-   */
-  SetRDSGroupMask(uint32_t groupMask);
 };
 
 } // namespace dom
 } // namespace mozilla
 
--- a/dom/webidl/FMRadio.webidl
+++ b/dom/webidl/FMRadio.webidl
@@ -1,19 +1,16 @@
 /* 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/. */
 
 interface FMRadio : EventTarget {
   /* Indicates if the FM radio is enabled. */
   readonly attribute boolean enabled;
 
-  /* Indicates if RDS reception is enabled */
-  readonly attribute boolean rdsEnabled;
-
   /* Indicates if the antenna is plugged and available. */
   readonly attribute boolean antennaAvailable;
 
   /**
    * Current frequency in MHz. The value will be null if the FM radio is
    * disabled.
    */
   readonly attribute double? frequency;
@@ -29,92 +26,31 @@ interface FMRadio : EventTarget {
    * is, any two radio channels' frequencies differ by at least channelWidth
    * MHz. Usually, the value is one of:
    *  - 0.05 MHz
    *  - 0.1  MHz
    *  - 0.2  MHz
    */
   readonly attribute double channelWidth;
 
-  /**
-   * This is a mask consisting of bits corresponding to
-   * (1 << groupcode) that can be specified to receive
-   * raw RDS groups of specific group types. Note that
-   * groupcode corresponds to the upper 5 bits in block B.
-   */
-  attribute unsigned long rdsGroupMask;
-
-  /**
-   * The Program Identification (PI) code.
-   * Available if RDS is enabled on both the station and on this device.
-   * The value is null otherwise.
-   */
-  readonly attribute unsigned short? pi;
-
-  /**
-   * The Program Type (PTY) code.
-   * Available if RDS is enabled on both the station and on this device.
-   * The value is null otherwise.
-   */
-  readonly attribute octet? pty;
-
-  /**
-   * The Program Service (PS) name.
-   * Available if RDS is enabled on the station and on this device
-   */
-  readonly attribute DOMString? ps;
-
-  /**
-   * The radiotext, as provided by group 2A/2B.
-   * Available if RDS is enabled on the station and on this device
-   */
-  readonly attribute DOMString? rt;
-
-  /**
-   * The last RDS group received.
-   * Available if RDS is enabled on the station and on this device
-   */
-  readonly attribute Uint16Array? rdsgroup;
-
   /* Fired when the FM radio is enabled. */
   attribute EventHandler onenabled;
 
   /* Fired when the FM radio is disabled. */
   attribute EventHandler ondisabled;
 
-  /* Fired when the RDS is enabled. */
-  attribute EventHandler onrdsenabled;
-
-  /* Fired when the RDS is disabled. */
-  attribute EventHandler onrdsdisabled;
-
   /**
    * Fired when the antenna becomes available or unavailable, i.e., fired when
    * the antennaAvailable attribute changes.
    */
   attribute EventHandler onantennaavailablechange;
 
   /* Fired when the FM radio's frequency is changed. */
   attribute EventHandler onfrequencychange;
 
-  /* Fired when the PI code changes */
-  attribute EventHandler onpichange;
-
-  /* Fired when the PTY changes */
-  attribute EventHandler onptychange;
-
-  /* Fired when the PS name changes */
-  attribute EventHandler onpschange;
-
-  /* Fired when the radiotext changes */
-  attribute EventHandler onrtchange;
-
-  /* Fired when we get a new RDS group */
-  attribute EventHandler onnewrdsgroup;
-
   /**
    * Power the FM radio off. The disabled event will be fired if this request
    * completes successfully.
    */
   DOMRequest disable();
 
   /**
    * Power the FM radio on, and tune the radio to the given frequency in MHz.
@@ -153,24 +89,10 @@ interface FMRadio : EventTarget {
    */
   DOMRequest seekDown();
 
   /**
    * Cancel the seek action. If the radio is not currently seeking up or down,
    * error will be fired.
    */
   DOMRequest cancelSeek();
-
-  /**
-   * Enable RDS reception.
-   *
-   * If the radio is off, RDS will be enabled when the radio is turned on.
-   */
-  DOMRequest enableRDS();
-
-  /**
-   * Disable RDS reception.
-   *
-   * If the radio is off, RDS will not be enabled when the radio is turned on.
-   */
-  DOMRequest disableRDS();
 };