From 06b4c7d3974670dc8387926c3eaa8cff8ee056b8 Mon Sep 17 00:00:00 2001 From: Gaia Pushbot Date: Thu, 19 Sep 2013 04:40:22 -0700 Subject: [PATCH 01/10] Bumping gaia.json for 2 gaia-central revision(s) a=NPOTB ======== https://hg.mozilla.org/integration/gaia-central/rev/98f191869b0c Author: Jose M. Cantera Desc: Merge pull request #12310 from jmcanterafonseca/bug-916096 Bug 916096 - [Contacts] Incorrect message to show the matching field in ... ======== https://hg.mozilla.org/integration/gaia-central/rev/c3470b4ea0ee Author: Jose M. Cantera Desc: Bug 916096 - [Contacts] Incorrect message to show the matching field in Merge duplicates screen --- b2g/config/gaia.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/b2g/config/gaia.json b/b2g/config/gaia.json index c12b4d6d4c73..bf2f2e364c8f 100644 --- a/b2g/config/gaia.json +++ b/b2g/config/gaia.json @@ -1,4 +1,4 @@ { - "revision": "9bf9368a1110d6c365225593e0f145c343ea8cd8", + "revision": "98f191869b0cc294923f7d4039b4e6bc292f26cc", "repo_path": "/integration/gaia-central" } From 3524a3c64f289e7ef80a28c3c575203873f41611 Mon Sep 17 00:00:00 2001 From: JW Wang Date: Wed, 18 Sep 2013 11:46:22 +0800 Subject: [PATCH 02/10] Bug 894249 - Add ability to associate video with a channel so that it can interrupt the background content channel. r=mchen, r=kinetik, r=bent --- content/html/content/src/HTMLMediaElement.cpp | 7 ++- dom/audiochannel/AudioChannelAgent.cpp | 15 ++++- dom/audiochannel/AudioChannelAgent.h | 3 +- dom/audiochannel/AudioChannelService.cpp | 60 ++++++++++++++----- dom/audiochannel/AudioChannelService.h | 15 +++-- dom/audiochannel/AudioChannelServiceChild.cpp | 27 +++------ dom/audiochannel/AudioChannelServiceChild.h | 3 +- dom/audiochannel/nsIAudioChannelAgent.idl | 11 +++- dom/ipc/ContentParent.cpp | 10 ++-- dom/ipc/ContentParent.h | 6 +- dom/ipc/PContent.ipdl | 5 +- 11 files changed, 109 insertions(+), 53 deletions(-) diff --git a/content/html/content/src/HTMLMediaElement.cpp b/content/html/content/src/HTMLMediaElement.cpp index 18843fd2af67..f73c68e9f330 100644 --- a/content/html/content/src/HTMLMediaElement.cpp +++ b/content/html/content/src/HTMLMediaElement.cpp @@ -3811,8 +3811,13 @@ void HTMLMediaElement::UpdateAudioChannelPlayingState() if (!mAudioChannelAgent) { return; } + nsCOMPtr video = do_QueryObject(this); // Use a weak ref so the audio channel agent can't leak |this|. - mAudioChannelAgent->InitWithWeakCallback(mAudioChannelType, this); + if (AUDIO_CHANNEL_NORMAL == mAudioChannelType && video) { + mAudioChannelAgent->InitWithVideo(mAudioChannelType, this, true); + } else { + mAudioChannelAgent->InitWithWeakCallback(mAudioChannelType, this); + } mAudioChannelAgent->SetVisibilityState(!OwnerDoc()->Hidden()); } diff --git a/dom/audiochannel/AudioChannelAgent.cpp b/dom/audiochannel/AudioChannelAgent.cpp index b9ae5d19cd9d..100f997b2a38 100644 --- a/dom/audiochannel/AudioChannelAgent.cpp +++ b/dom/audiochannel/AudioChannelAgent.cpp @@ -22,6 +22,7 @@ AudioChannelAgent::AudioChannelAgent() : mAudioChannelType(AUDIO_AGENT_CHANNEL_ERROR) , mIsRegToService(false) , mVisible(true) + , mWithVideo(false) { } @@ -54,10 +55,18 @@ AudioChannelAgent::InitWithWeakCallback(int32_t channelType, return InitInternal(channelType, callback, /* useWeakRef = */ true); } +NS_IMETHODIMP +AudioChannelAgent::InitWithVideo(int32_t channelType, + nsIAudioChannelAgentCallback *callback, + bool aUseWeakRef) +{ + return InitInternal(channelType, callback, aUseWeakRef, true); +} + nsresult AudioChannelAgent::InitInternal(int32_t aChannelType, nsIAudioChannelAgentCallback *aCallback, - bool aUseWeakRef) + bool aUseWeakRef, bool aWithVideo) { // We syncd the enum of channel type between nsIAudioChannelAgent.idl and // AudioChannelCommon.h the same. @@ -91,6 +100,8 @@ AudioChannelAgent::InitInternal(int32_t aChannelType, mCallback = aCallback; } + mWithVideo = aWithVideo; + return NS_OK; } @@ -104,7 +115,7 @@ NS_IMETHODIMP AudioChannelAgent::StartPlaying(int32_t *_retval) } service->RegisterAudioChannelAgent(this, - static_cast(mAudioChannelType)); + static_cast(mAudioChannelType), mWithVideo); *_retval = service->GetState(this, !mVisible); mIsRegToService = true; return NS_OK; diff --git a/dom/audiochannel/AudioChannelAgent.h b/dom/audiochannel/AudioChannelAgent.h index a4900f72b337..44b482e87bdb 100644 --- a/dom/audiochannel/AudioChannelAgent.h +++ b/dom/audiochannel/AudioChannelAgent.h @@ -41,13 +41,14 @@ private: nsresult InitInternal(int32_t aAudioAgentType, nsIAudioChannelAgentCallback* aCallback, - bool aUseWeakRef); + bool aUseWeakRef, bool aWithVideo=false); nsCOMPtr mCallback; nsWeakPtr mWeakCallback; int32_t mAudioChannelType; bool mIsRegToService; bool mVisible; + bool mWithVideo; }; } // namespace dom diff --git a/dom/audiochannel/AudioChannelService.cpp b/dom/audiochannel/AudioChannelService.cpp index 02cc09d9cdbb..dcfa0a469a5a 100644 --- a/dom/audiochannel/AudioChannelService.cpp +++ b/dom/audiochannel/AudioChannelService.cpp @@ -93,19 +93,21 @@ AudioChannelService::~AudioChannelService() void AudioChannelService::RegisterAudioChannelAgent(AudioChannelAgent* aAgent, - AudioChannelType aType) + AudioChannelType aType, + bool aWithVideo) { MOZ_ASSERT(aType != AUDIO_CHANNEL_DEFAULT); AudioChannelAgentData* data = new AudioChannelAgentData(aType, true /* aElementHidden */, - AUDIO_CHANNEL_STATE_MUTED /* aState */); + AUDIO_CHANNEL_STATE_MUTED /* aState */, + aWithVideo); mAgents.Put(aAgent, data); - RegisterType(aType, CONTENT_PROCESS_ID_MAIN); + RegisterType(aType, CONTENT_PROCESS_ID_MAIN, aWithVideo); } void -AudioChannelService::RegisterType(AudioChannelType aType, uint64_t aChildID) +AudioChannelService::RegisterType(AudioChannelType aType, uint64_t aChildID, bool aWithVideo) { AudioChannelInternalType type = GetInternalType(aType, true); mChannelCounters[type].AppendElement(aChildID); @@ -116,7 +118,11 @@ AudioChannelService::RegisterType(AudioChannelType aType, uint64_t aChildID) if (mDeferTelChannelTimer && aType == AUDIO_CHANNEL_TELEPHONY) { mDeferTelChannelTimer->Cancel(); mDeferTelChannelTimer = nullptr; - UnregisterTypeInternal(aType, mTimerElementHidden, mTimerChildID); + UnregisterTypeInternal(aType, mTimerElementHidden, mTimerChildID, false); + } + + if (aWithVideo) { + mWithVideoChildIDs.AppendElement(aChildID); } // In order to avoid race conditions, it's safer to notify any existing @@ -133,14 +139,16 @@ AudioChannelService::UnregisterAudioChannelAgent(AudioChannelAgent* aAgent) mAgents.RemoveAndForget(aAgent, data); if (data) { - UnregisterType(data->mType, data->mElementHidden, CONTENT_PROCESS_ID_MAIN); + UnregisterType(data->mType, data->mElementHidden, + CONTENT_PROCESS_ID_MAIN, data->mWithVideo); } } void AudioChannelService::UnregisterType(AudioChannelType aType, bool aElementHidden, - uint64_t aChildID) + uint64_t aChildID, + bool aWithVideo) { // 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. @@ -156,13 +164,14 @@ AudioChannelService::UnregisterType(AudioChannelType aType, return; } - UnregisterTypeInternal(aType, aElementHidden, aChildID); + UnregisterTypeInternal(aType, aElementHidden, aChildID, aWithVideo); } void AudioChannelService::UnregisterTypeInternal(AudioChannelType aType, bool aElementHidden, - uint64_t aChildID) + uint64_t aChildID, + bool aWithVideo) { // The array may contain multiple occurrence of this appId but // this should remove only the first one. @@ -181,6 +190,12 @@ AudioChannelService::UnregisterTypeInternal(AudioChannelType aType, !mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].Contains(aChildID)) { mActiveContentChildIDs.RemoveElement(aChildID); } + + if (aWithVideo) { + MOZ_ASSERT(mWithVideoChildIDs.Contains(aChildID)); + mWithVideoChildIDs.RemoveElement(aChildID); + } + SendAudioChannelChangedNotification(aChildID); Notify(); } @@ -258,8 +273,19 @@ AudioChannelService::GetStateInternal(AudioChannelType aType, uint64_t aChildID, mActiveContentChildIDs.RemoveElement(aChildID); } } + else if (newType == AUDIO_CHANNEL_INT_NORMAL && + oldType == AUDIO_CHANNEL_INT_NORMAL_HIDDEN && + mWithVideoChildIDs.Contains(aChildID)) { + if (mActiveContentChildIDsFrozen) { + mActiveContentChildIDsFrozen = false; + mActiveContentChildIDs.Clear(); + } + } - if (newType != oldType && aType == AUDIO_CHANNEL_CONTENT) { + if (newType != oldType && + (aType == AUDIO_CHANNEL_CONTENT || + (aType == AUDIO_CHANNEL_NORMAL && + mWithVideoChildIDs.Contains(aChildID)))) { Notify(); } @@ -508,7 +534,7 @@ AudioChannelService::Notify() NS_IMETHODIMP AudioChannelService::Notify(nsITimer* aTimer) { - UnregisterTypeInternal(AUDIO_CHANNEL_TELEPHONY, mTimerElementHidden, mTimerChildID); + UnregisterTypeInternal(AUDIO_CHANNEL_TELEPHONY, mTimerElementHidden, mTimerChildID, false); mDeferTelChannelTimer = nullptr; return NS_OK; } @@ -569,6 +595,7 @@ AudioChannelService::Observe(nsISupports* aSubject, const char* aTopic, const PR return NS_OK; } + int32_t index; uint64_t childID = 0; nsresult rv = props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"), &childID); @@ -576,14 +603,17 @@ AudioChannelService::Observe(nsISupports* aSubject, const char* aTopic, const PR for (int32_t type = AUDIO_CHANNEL_INT_NORMAL; type < AUDIO_CHANNEL_INT_LAST; ++type) { - int32_t index; + while ((index = mChannelCounters[type].IndexOf(childID)) != -1) { mChannelCounters[type].RemoveElementAt(index); } + } - if ((index = mActiveContentChildIDs.IndexOf(childID)) != -1) { - mActiveContentChildIDs.RemoveElementAt(index); - } + while ((index = mActiveContentChildIDs.IndexOf(childID)) != -1) { + mActiveContentChildIDs.RemoveElementAt(index); + } + while ((index = mWithVideoChildIDs.IndexOf(childID)) != -1) { + mWithVideoChildIDs.RemoveElementAt(index); } // We don't have to remove the agents from the mAgents hashtable because if diff --git a/dom/audiochannel/AudioChannelService.h b/dom/audiochannel/AudioChannelService.h index 2d96ef54ad8a..a696ca2da9c2 100644 --- a/dom/audiochannel/AudioChannelService.h +++ b/dom/audiochannel/AudioChannelService.h @@ -46,7 +46,8 @@ public: * this service, sharing the AudioChannelType. */ virtual void RegisterAudioChannelAgent(AudioChannelAgent* aAgent, - AudioChannelType aType); + AudioChannelType aType, + bool aWithVideo); /** * Any audio channel agent that stops playing should unregister itself to @@ -90,11 +91,11 @@ protected: void SendAudioChannelChangedNotification(uint64_t aChildID); /* Register/Unregister IPC types: */ - void RegisterType(AudioChannelType aType, uint64_t aChildID); + void RegisterType(AudioChannelType aType, uint64_t aChildID, bool aWithVideo); void UnregisterType(AudioChannelType aType, bool aElementHidden, - uint64_t aChildID); + uint64_t aChildID, bool aWithVideo); void UnregisterTypeInternal(AudioChannelType aType, bool aElementHidden, - uint64_t aChildID); + uint64_t aChildID, bool aWithVideo); AudioChannelState GetStateInternal(AudioChannelType aType, uint64_t aChildID, bool aElementHidden, @@ -143,15 +144,18 @@ protected: public: AudioChannelAgentData(AudioChannelType aType, bool aElementHidden, - AudioChannelState aState) + AudioChannelState aState, + bool aWithVideo) : mType(aType) , mElementHidden(aElementHidden) , mState(aState) + , mWithVideo(aWithVideo) {} AudioChannelType mType; bool mElementHidden; AudioChannelState mState; + const bool mWithVideo; }; static PLDHashOperator @@ -166,6 +170,7 @@ protected: AudioChannelType mCurrentVisibleHigherChannel; nsTArray mActiveContentChildIDs; + nsTArray mWithVideoChildIDs; bool mActiveContentChildIDsFrozen; nsCOMPtr mDeferTelChannelTimer; diff --git a/dom/audiochannel/AudioChannelServiceChild.cpp b/dom/audiochannel/AudioChannelServiceChild.cpp index 0dc4977a8658..736cb74b8554 100644 --- a/dom/audiochannel/AudioChannelServiceChild.cpp +++ b/dom/audiochannel/AudioChannelServiceChild.cpp @@ -66,7 +66,6 @@ AudioChannelServiceChild::GetState(AudioChannelAgent* aAgent, bool aElementHidde return AUDIO_CHANNEL_STATE_MUTED; } - ContentChild *cc = ContentChild::GetSingleton(); AudioChannelState state = AUDIO_CHANNEL_STATE_MUTED; bool oldElementHidden = data->mElementHidden; @@ -75,30 +74,24 @@ AudioChannelServiceChild::GetState(AudioChannelAgent* aAgent, bool aElementHidde // Update visibility. data->mElementHidden = aElementHidden; - if (cc) { - cc->SendAudioChannelGetState(data->mType, aElementHidden, oldElementHidden, &state); - } + ContentChild* cc = ContentChild::GetSingleton(); + cc->SendAudioChannelGetState(data->mType, aElementHidden, oldElementHidden, &state); data->mState = state; - - if (cc) { - cc->SendAudioChannelChangedNotification(); - } + cc->SendAudioChannelChangedNotification(); return state; } void AudioChannelServiceChild::RegisterAudioChannelAgent(AudioChannelAgent* aAgent, - AudioChannelType aType) + AudioChannelType aType, + bool aWithVideo) { MOZ_ASSERT(aType != AUDIO_CHANNEL_DEFAULT); - AudioChannelService::RegisterAudioChannelAgent(aAgent, aType); + AudioChannelService::RegisterAudioChannelAgent(aAgent, aType, aWithVideo); - ContentChild *cc = ContentChild::GetSingleton(); - if (cc) { - cc->SendAudioChannelRegisterType(aType); - } + ContentChild::GetSingleton()->SendAudioChannelRegisterType(aType, aWithVideo); nsCOMPtr obs = mozilla::services::GetObserverService(); if (obs) { @@ -120,10 +113,8 @@ AudioChannelServiceChild::UnregisterAudioChannelAgent(AudioChannelAgent* aAgent) AudioChannelService::UnregisterAudioChannelAgent(aAgent); - ContentChild *cc = ContentChild::GetSingleton(); - if (cc) { - cc->SendAudioChannelUnregisterType(data.mType, data.mElementHidden); - } + ContentChild::GetSingleton()->SendAudioChannelUnregisterType( + data.mType, data.mElementHidden, data.mWithVideo); nsCOMPtr obs = mozilla::services::GetObserverService(); if (obs) { diff --git a/dom/audiochannel/AudioChannelServiceChild.h b/dom/audiochannel/AudioChannelServiceChild.h index 90462562518a..a51762bdfa14 100644 --- a/dom/audiochannel/AudioChannelServiceChild.h +++ b/dom/audiochannel/AudioChannelServiceChild.h @@ -31,7 +31,8 @@ public: static void Shutdown(); virtual void RegisterAudioChannelAgent(AudioChannelAgent* aAgent, - AudioChannelType aType); + AudioChannelType aType, + bool aWithVideo); virtual void UnregisterAudioChannelAgent(AudioChannelAgent* aAgent); /** diff --git a/dom/audiochannel/nsIAudioChannelAgent.idl b/dom/audiochannel/nsIAudioChannelAgent.idl index 1795bdb70ab3..2158d07f2e6b 100644 --- a/dom/audiochannel/nsIAudioChannelAgent.idl +++ b/dom/audiochannel/nsIAudioChannelAgent.idl @@ -32,7 +32,7 @@ interface nsIAudioChannelAgentCallback : nsISupports * 1. Changes to the playable status of this channel. */ -[scriptable, uuid(7a4c0b06-63a4-11e2-8c1b-10bf48d64bd4)] +[scriptable, uuid(86ef883d-9cec-4c04-994f-5de198286e7c)] interface nsIAudioChannelAgent : nsISupports { const long AUDIO_AGENT_CHANNEL_NORMAL = 0; @@ -78,6 +78,14 @@ interface nsIAudioChannelAgent : nsISupports */ void initWithWeakCallback(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 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 @@ -110,6 +118,5 @@ interface nsIAudioChannelAgent : nsISupports * True if the window associated with the agent is visible. */ void setVisibilityState(in boolean visible); - }; diff --git a/dom/ipc/ContentParent.cpp b/dom/ipc/ContentParent.cpp index 905d02f00211..52e13b9d67fc 100644 --- a/dom/ipc/ContentParent.cpp +++ b/dom/ipc/ContentParent.cpp @@ -1597,24 +1597,26 @@ ContentParent::RecvAudioChannelGetState(const AudioChannelType& aType, } bool -ContentParent::RecvAudioChannelRegisterType(const AudioChannelType& aType) +ContentParent::RecvAudioChannelRegisterType(const AudioChannelType& aType, + const bool& aWithVideo) { nsRefPtr service = AudioChannelService::GetAudioChannelService(); if (service) { - service->RegisterType(aType, mChildID); + service->RegisterType(aType, mChildID, aWithVideo); } return true; } bool ContentParent::RecvAudioChannelUnregisterType(const AudioChannelType& aType, - const bool& aElementHidden) + const bool& aElementHidden, + const bool& aWithVideo) { nsRefPtr service = AudioChannelService::GetAudioChannelService(); if (service) { - service->UnregisterType(aType, aElementHidden, mChildID); + service->UnregisterType(aType, aElementHidden, mChildID, aWithVideo); } return true; } diff --git a/dom/ipc/ContentParent.h b/dom/ipc/ContentParent.h index 3f0ca8a06d60..6fb06d3ba381 100644 --- a/dom/ipc/ContentParent.h +++ b/dom/ipc/ContentParent.h @@ -420,9 +420,11 @@ private: const bool& aElementWasHidden, AudioChannelState* aValue); - virtual bool RecvAudioChannelRegisterType(const AudioChannelType& aType); + virtual bool RecvAudioChannelRegisterType(const AudioChannelType& aType, + const bool& aWithVideo); virtual bool RecvAudioChannelUnregisterType(const AudioChannelType& aType, - const bool& aElementHidden); + const bool& aElementHidden, + const bool& aWithVideo); virtual bool RecvAudioChannelChangedNotification(); diff --git a/dom/ipc/PContent.ipdl b/dom/ipc/PContent.ipdl index 00914c3dbc85..cb9e440671ac 100644 --- a/dom/ipc/PContent.ipdl +++ b/dom/ipc/PContent.ipdl @@ -442,9 +442,10 @@ parent: bool aElementWasHidden) returns (AudioChannelState value); - sync AudioChannelRegisterType(AudioChannelType aType); + sync AudioChannelRegisterType(AudioChannelType aType, bool aWithVideo); sync AudioChannelUnregisterType(AudioChannelType aType, - bool aElementHidden); + bool aElementHidden, + bool aWithVideo); async AudioChannelChangedNotification(); async AudioChannelChangeDefVolChannel(AudioChannelType aType, From a567947cc2645959e2ba5f4b8069ee53c975a62c Mon Sep 17 00:00:00 2001 From: pzhang Date: Wed, 11 Sep 2013 13:41:52 +0800 Subject: [PATCH 03/10] Bug 911063 - Add marionette tests for WebFM. r=khuey --- dom/fmradio/test/marionette/manifest.ini | 14 +++ dom/fmradio/test/marionette/test_bug862672.js | 53 +++++++++++ dom/fmradio/test/marionette/test_bug876597.js | 90 +++++++++++++++++++ .../test/marionette/test_cancel_seek.js | 69 ++++++++++++++ .../test/marionette/test_enable_disable.js | 85 ++++++++++++++++++ .../test/marionette/test_one_seek_at_once.js | 73 +++++++++++++++ .../test/marionette/test_seek_up_and_down.js | 61 +++++++++++++ .../test/marionette/test_set_frequency.js | 87 ++++++++++++++++++ 8 files changed, 532 insertions(+) create mode 100644 dom/fmradio/test/marionette/manifest.ini create mode 100644 dom/fmradio/test/marionette/test_bug862672.js create mode 100644 dom/fmradio/test/marionette/test_bug876597.js create mode 100644 dom/fmradio/test/marionette/test_cancel_seek.js create mode 100644 dom/fmradio/test/marionette/test_enable_disable.js create mode 100644 dom/fmradio/test/marionette/test_one_seek_at_once.js create mode 100644 dom/fmradio/test/marionette/test_seek_up_and_down.js create mode 100644 dom/fmradio/test/marionette/test_set_frequency.js diff --git a/dom/fmradio/test/marionette/manifest.ini b/dom/fmradio/test/marionette/manifest.ini new file mode 100644 index 000000000000..5039789e04f8 --- /dev/null +++ b/dom/fmradio/test/marionette/manifest.ini @@ -0,0 +1,14 @@ +[DEFAULT] +b2g = true +browser = false +; We don't support FM radio emulation yet, see bug 872417 +qemu = false + +[test_enable_disable.js] +[test_set_frequency.js] +[test_cancel_seek.js] +[test_one_seek_at_once.js] +[test_seek_up_and_down.js] +[test_bug862672.js] +[test_bug876597.js] + diff --git a/dom/fmradio/test/marionette/test_bug862672.js b/dom/fmradio/test/marionette/test_bug862672.js new file mode 100644 index 000000000000..681d1dc4b7c2 --- /dev/null +++ b/dom/fmradio/test/marionette/test_bug862672.js @@ -0,0 +1,53 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 10000; + +SpecialPowers.addPermission("fmradio", true, document); + +let FMRadio = window.navigator.mozFMRadio; + +function verifyInitialState() { + log("Verifying initial state."); + ok(FMRadio); + is(FMRadio.enabled, false); + enableThenDisable(); +} + +function enableThenDisable() { + log("Enable FM Radio and disable it immediately."); + var frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + var request = FMRadio.enable(frequency); + ok(request); + + var failedToEnable = false; + request.onerror = function() { + failedToEnable = true; + }; + + var enableCompleted = false; + request.onsuccess = function() { + ok(!failedToEnable); + enableCompleted = true; + }; + + var disableReq = FMRadio.disable(); + ok(disableReq); + + disableReq.onsuccess = function() { + // There are two possibilities which depends on the system + // process scheduling (bug 911063 comment 0): + // - enable fails + // - enable's onsuccess fires before disable's onsucess + ok(failedToEnable || enableCompleted); + ok(!FMRadio.enabled); + finish(); + }; + + disableReq.onerror = function() { + ok(false, "Disable request should not fail."); + }; +} + +verifyInitialState(); + diff --git a/dom/fmradio/test/marionette/test_bug876597.js b/dom/fmradio/test/marionette/test_bug876597.js new file mode 100644 index 000000000000..1b7dde93330e --- /dev/null +++ b/dom/fmradio/test/marionette/test_bug876597.js @@ -0,0 +1,90 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 10000; + +SpecialPowers.addPermission("fmradio", true, document); +SpecialPowers.addPermission("settings-read", true, document); +SpecialPowers.addPermission("settings-write", true, document); + +let FMRadio = window.navigator.mozFMRadio; +let mozSettings = window.navigator.mozSettings; +let KEY = "ril.radio.disabled"; + +function verifyInitialState() { + log("Verifying initial state."); + ok(FMRadio); + is(FMRadio.enabled, false); + ok(mozSettings); + + checkRilSettings(); +} + +function checkRilSettings() { + log("Checking airplane mode settings"); + let req = mozSettings.createLock().get(KEY); + req.onsuccess = function(event) { + ok(!req.result[KEY], "Airplane mode is disabled."); + enableFMRadio(); + }; + + req.onerror = function() { + ok(false, "Error occurs when reading settings value."); + finish(); + }; +} + +function enableFMRadio() { + log("Enable FM radio"); + let frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + let req = FMRadio.enable(frequency); + + req.onsuccess = function() { + enableAirplaneMode(); + }; + + req.onerror = function() { + ok(false, "Failed to enable FM radio."); + }; +} + +function enableAirplaneMode() { + log("Enable airplane mode"); + FMRadio.ondisabled = function() { + FMRadio.ondisabled = null; + enableFMRadioWithAirplaneModeEnabled(); + }; + + let settings = {}; + settings[KEY] = true; + mozSettings.createLock().set(settings); +} + +function enableFMRadioWithAirplaneModeEnabled() { + log("Enable FM radio with airplane mode enabled"); + let frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + let req = FMRadio.enable(frequency); + req.onerror = cleanUp(); + + req.onsuccess = function() { + ok(false, "FMRadio could be enabled when airplane mode is enabled."); + }; +} + +function cleanUp() { + let settings = {}; + settings[KEY] = false; + let req = mozSettings.createLock().set(settings); + + req.onsuccess = function() { + ok(!FMRadio.enabled); + finish(); + }; + + req.onerror = function() { + ok(false, "Error occurs when setting value"); + }; +} + +verifyInitialState(); + diff --git a/dom/fmradio/test/marionette/test_cancel_seek.js b/dom/fmradio/test/marionette/test_cancel_seek.js new file mode 100644 index 000000000000..ea9d6ad3f420 --- /dev/null +++ b/dom/fmradio/test/marionette/test_cancel_seek.js @@ -0,0 +1,69 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 10000; + +SpecialPowers.addPermission("fmradio", true, document); + +let FMRadio = window.navigator.mozFMRadio; + +function verifyInitialState() { + log("Verifying initial state."); + ok(FMRadio); + is(FMRadio.enabled, false); + setUp(); +} + +function setUp() { + let frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + FMRadio.enable(frequency); + FMRadio.onenabled = seek; +} + +function seek() { + log("Seek up"); + var request = FMRadio.seekUp(); + ok(request); + + var seekUpIsCancelled = false; + request.onerror = function() { + seekUpIsCancelled = true; + }; + + var seekUpCompleted = false; + request.onsuccess = function() { + ok(!seekUpIsCancelled); + seekUpCompleted = true; + }; + + log("Seek up"); + var cancelSeekReq = FMRadio.cancelSeek(); + ok(cancelSeekReq); + + // There are two possibilities which depends on the system + // process scheduling (bug 911063 comment 0): + // - seekup action is canceled + // - seekup's onsuccess fires before cancelSeek's onerror + + cancelSeekReq.onsuccess = function() { + ok(seekUpIsCancelled, "Seekup request failed."); + cleanUp(); + }; + + cancelSeekReq.onerror = function() { + ok(seekUpCompleted); + cleanUp(); + }; +} + +function cleanUp() { + FMRadio.disable(); + FMRadio.ondisabled = function() { + FMRadio.ondisabled = null; + ok(!FMRadio.enabled); + finish(); + }; +} + +verifyInitialState(); + diff --git a/dom/fmradio/test/marionette/test_enable_disable.js b/dom/fmradio/test/marionette/test_enable_disable.js new file mode 100644 index 000000000000..c1c380793bd2 --- /dev/null +++ b/dom/fmradio/test/marionette/test_enable_disable.js @@ -0,0 +1,85 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 10000; + +SpecialPowers.addPermission("fmradio", true, document); + +let FMRadio = window.navigator.mozFMRadio; + +function verifyInitialState() { + log("Verifying initial state."); + ok(FMRadio); + is(FMRadio.enabled, false); + + log("Verifying attributes when disabled."); + is(FMRadio.frequency, null); + ok(FMRadio.frequencyLowerBound); + ok(FMRadio.frequencyUpperBound); + ok(FMRadio.frequencyUpperBound > FMRadio.frequencyLowerBound); + ok(FMRadio.channelWidth); + + enableFMRadio(); +} + +function enableFMRadio() { + log("Verifying behaviors when enabled."); + var frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + var request = FMRadio.enable(frequency); + ok(request, "FMRadio.enable(r" + frequency + ") returns request"); + + request.onsuccess = function() { + ok(FMRadio.enabled); + ok(typeof FMRadio.frequency == "number"); + ok(FMRadio.frequency > FMRadio.frequencyLowerBound); + }; + + request.onerror = function() { + ok(null, "Failed to enable"); + }; + + var enabled = false; + FMRadio.onenabled = function() { + FMRadio.onenabled = null; + enabled = FMRadio.enabled; + }; + + FMRadio.onfrequencychange = function() { + log("Check if 'onfrequencychange' event is fired after the 'enabled' event"); + FMRadio.onfrequencychange = null; + ok(enabled, "FMRadio is enabled when handling `onfrequencychange`"); + disableFMRadio(); + }; +} + +function disableFMRadio() { + log("Verify behaviors when disabled"); + + // There are two possibilities which depends on the system + // process scheduling (bug 911063 comment 0): + // - seek fails + // - seek's onsuccess fires before disable's onsucess + var seekRequest = FMRadio.seekUp(); + var seekCompletes = false; + var failedToSeek = false; + seekRequest.onerror = function() { + ok(!seekCompletes); + failedToSeek = true; + }; + + seekRequest.onsuccess = function() { + ok(!failedToSeek); + seekCompletes = true; + }; + + FMRadio.disable(); + FMRadio.ondisabled = function() { + FMRadio.ondisabled = null; + ok(seekCompletes || failedToSeek); + ok(!FMRadio.enabled); + finish(); + }; +} + +verifyInitialState(); + diff --git a/dom/fmradio/test/marionette/test_one_seek_at_once.js b/dom/fmradio/test/marionette/test_one_seek_at_once.js new file mode 100644 index 000000000000..cf8c5d014cdb --- /dev/null +++ b/dom/fmradio/test/marionette/test_one_seek_at_once.js @@ -0,0 +1,73 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 10000; + +SpecialPowers.addPermission("fmradio", true, document); + +let FMRadio = window.navigator.mozFMRadio; + +function verifyInitialState() { + log("Verifying initial state."); + ok(FMRadio); + is(FMRadio.enabled, false); + setUp(); +} + +function setUp() { + let frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + FMRadio.enable(frequency); + FMRadio.onenabled = seek; +} + +function seek() { + var request = FMRadio.seekUp(); + ok(request); + + // There are two possibilities which depends on the system + // process scheduling (bug 911063 comment 0): + // - the second seek fails + // - both seeks are executed + + request.onerror = function() { + ok(!firstSeekCompletes); + cleanUp(); + }; + + var firstSeekCompletes = false; + request.onsuccess = function() { + firstSeekCompletes = true; + }; + + var seekAgainReq = FMRadio.seekUp(); + ok(seekAgainReq); + + seekAgainReq.onerror = function() { + log("Cancel the first seek to finish the test"); + let cancelReq = FMRadio.cancelSeek(); + ok(cancelReq); + + // It's possible that the first seek completes when the + // cancel request is handled. + cancelReq.onerror = function() { + cleanUp(); + }; + }; + + seekAgainReq.onsuccess = function() { + ok(firstSeekCompletes); + cleanUp(); + }; +} + +function cleanUp() { + FMRadio.disable(); + FMRadio.ondisabled = function() { + FMRadio.ondisabled = null; + ok(!FMRadio.enabled); + finish(); + }; +} + +verifyInitialState(); + diff --git a/dom/fmradio/test/marionette/test_seek_up_and_down.js b/dom/fmradio/test/marionette/test_seek_up_and_down.js new file mode 100644 index 000000000000..e0dabda7d14c --- /dev/null +++ b/dom/fmradio/test/marionette/test_seek_up_and_down.js @@ -0,0 +1,61 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 30000; + +SpecialPowers.addPermission("fmradio", true, document); + +let FMRadio = window.navigator.mozFMRadio; + +function verifyInitialState() { + log("Verifying initial state."); + ok(FMRadio); + is(FMRadio.enabled, false); + setUp(); +} + +function setUp() { + let frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + FMRadio.enable(frequency); + FMRadio.onenabled = seekUp; +} + +function seekUp() { + log("Seek up"); + var request = FMRadio.seekUp(); + ok(request); + + request.onsuccess = function() { + seekDown(); + }; + + request.onerror = function() { + ok(false, "Seekup request should not fail."); + }; +} + +function seekDown() { + log("Seek down"); + var request = FMRadio.seekDown(); + ok(request); + + request.onsuccess = function() { + cleanUp(); + }; + + request.onerror = function() { + ok(false, "Seekdown request should not fail."); + }; +} + +function cleanUp() { + FMRadio.disable(); + FMRadio.ondisabled = function() { + FMRadio.ondisabled = null; + ok(!FMRadio.enabled); + finish(); + }; +} + +verifyInitialState(); + diff --git a/dom/fmradio/test/marionette/test_set_frequency.js b/dom/fmradio/test/marionette/test_set_frequency.js new file mode 100644 index 000000000000..15e4be07aa4d --- /dev/null +++ b/dom/fmradio/test/marionette/test_set_frequency.js @@ -0,0 +1,87 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 10000; + +SpecialPowers.addPermission("fmradio", true, document); + +let FMRadio = window.navigator.mozFMRadio; + +function verifyInitialState() { + log("Verifying initial state."); + ok(FMRadio); + is(FMRadio.enabled, false); + setUp(); +} + +function setUp() { + let frequency = FMRadio.frequencyLowerBound + FMRadio.channelWidth; + FMRadio.enable(frequency); + FMRadio.onenabled = setFrequency; +} + +function setFrequency() { + log("Set Frequency"); + let frequency = FMRadio.frequency + FMRadio.channelWidth; + var request = FMRadio.setFrequency(frequency); + ok(request); + + request.onsuccess = setOutOfRangeFrequency; + request.onerror = function() { + ok(false, "setFrequency request should not fail."); + }; +} + +function setOutOfRangeFrequency() { + log("Set Frequency that out of the range"); + var request = FMRadio.setFrequency(FMRadio.frequencyUpperBound + 1); + ok(request); + + request.onsuccess = function() { + ok(false, "The request of setting an out-of-range frequency should fail."); + }; + request.onerror = setFrequencyWhenSeeking; +} + +function setFrequencyWhenSeeking() { + log("Set frequency when seeking"); + var request = FMRadio.seekUp(); + ok(request); + + // There are two possibilities which depends on the system + // process scheduling (bug 911063 comment 0): + // - seek fails + // - seek's onsuccess fires before setFrequency's onsucess + + var failedToSeek = false; + request.onerror = function() { + failedToSeek = true; + }; + + var seekCompletes = false; + request.onsuccess = function() { + ok(!failedToSeek); + seekCompletes = true; + }; + + var frequency = FMRadio.frequencyUpperBound - FMRadio.channelWidth; + var setFreqRequest = FMRadio.setFrequency(frequency); + ok(setFreqRequest); + + setFreqRequest.onsuccess = function() { + ok(failedToSeek || seekCompletes); + cleanUp(); + }; +} + +function cleanUp() { + FMRadio.disable(); + FMRadio.ondisabled = function() { + FMRadio.ondisabled = null; + ok(!FMRadio.enabled); + finish(); + }; +} + +verifyInitialState(); + From e88bb95a6464806985c299888fb7e61b75c58a1a Mon Sep 17 00:00:00 2001 From: Chia-hung Tai Date: Wed, 18 Sep 2013 11:04:16 +0800 Subject: [PATCH 04/10] Bug 917163 - [MMS] MMS Data call is not released immediately. r=vyang --- b2g/app/b2g.js | 3 +++ dom/mobilemessage/src/gonk/MmsService.js | 11 +++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/b2g/app/b2g.js b/b2g/app/b2g.js index 6df7c1c7b910..45a6c7b647a7 100644 --- a/b2g/app/b2g.js +++ b/b2g/app/b2g.js @@ -389,6 +389,9 @@ pref("dom.sms.strict7BitEncoding", false); // Disabled by default. pref("dom.sms.requestStatusReport", true); // Enabled by default. pref("dom.mms.requestStatusReport", true); // Enabled by default. +//The waiting time in network manager. +pref("network.gonk.ms-release-mms-connection", 30000); + // WebContacts pref("dom.mozContacts.enabled", true); pref("dom.navigator-property.disable.mozContacts", false); diff --git a/dom/mobilemessage/src/gonk/MmsService.js b/dom/mobilemessage/src/gonk/MmsService.js index d6fa07851f4c..24fad7c7dde7 100644 --- a/dom/mobilemessage/src/gonk/MmsService.js +++ b/dom/mobilemessage/src/gonk/MmsService.js @@ -60,7 +60,8 @@ const CONFIG_SEND_REPORT_DEFAULT_YES = 2; const CONFIG_SEND_REPORT_ALWAYS = 3; const TIME_TO_BUFFER_MMS_REQUESTS = 30000; -const TIME_TO_RELEASE_MMS_CONNECTION = 30000; +const PREF_TIME_TO_RELEASE_MMS_CONNECTION = + Services.prefs.getIntPref("network.gonk.ms-release-mms-connection"); const PREF_RETRIEVAL_MODE = 'dom.mms.retrieval_mode'; const RETRIEVAL_MODE_MANUAL = "manual"; @@ -293,11 +294,17 @@ XPCOMUtils.defineLazyGetter(this, "gMmsConnection", function () { if (this.refCount <= 0) { this.refCount = 0; + // The waiting is too small, just skip the timer creation. + if (PREF_TIME_TO_RELEASE_MMS_CONNECTION < 1000) { + this.onDisconnectTimerTimeout(); + return; + } + // Set a timer to delay the release of MMS network connection, // since the MMS requests often come consecutively in a short time. this.disconnectTimer. initWithCallback(this.onDisconnectTimerTimeout.bind(this), - TIME_TO_RELEASE_MMS_CONNECTION, + PREF_TIME_TO_RELEASE_MMS_CONNECTION, Ci.nsITimer.TYPE_ONE_SHOT); } }, From 7c55c168cdcd265468c44e0c73b51a9f095214bf Mon Sep 17 00:00:00 2001 From: "Szu-Yu Chen [:aknow]" Date: Thu, 19 Sep 2013 08:32:51 -0400 Subject: [PATCH 05/10] Bug 805838 - Add MARIONETTE_HEAD_JS support. r=jgriffin --- testing/marionette/client/marionette/marionette_test.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/testing/marionette/client/marionette/marionette_test.py b/testing/marionette/client/marionette/marionette_test.py index 4ca94fd2cdc1..da991739c66b 100644 --- a/testing/marionette/client/marionette/marionette_test.py +++ b/testing/marionette/client/marionette/marionette_test.py @@ -337,6 +337,7 @@ class MarionetteTestCase(CommonTestCase): class MarionetteJSTestCase(CommonTestCase): + head_js_re = re.compile(r"MARIONETTE_HEAD_JS(\s*)=(\s*)['|\"](.*?)['|\"];") context_re = re.compile(r"MARIONETTE_CONTEXT(\s*)=(\s*)['|\"](.*?)['|\"];") timeout_re = re.compile(r"MARIONETTE_TIMEOUT(\s*)=(\s*)(\d+);") inactivity_timeout_re = re.compile(r"MARIONETTE_INACTIVITY_TIMEOUT(\s*)=(\s*)(\d+);") @@ -376,6 +377,13 @@ class MarionetteJSTestCase(CommonTestCase): else: js += line + if os.path.basename(self.jsFile).startswith('test_'): + head_js = self.head_js_re.search(js); + if head_js: + head_js = head_js.group(3) + head = open(os.path.join(os.path.dirname(self.jsFile), head_js), 'r') + js = head.read() + js; + context = self.context_re.search(js) if context: context = context.group(3) From 42fe1aad188f9e7c835f9a93364da17747f488e3 Mon Sep 17 00:00:00 2001 From: Gaia Pushbot Date: Thu, 19 Sep 2013 05:35:27 -0700 Subject: [PATCH 06/10] Bumping gaia.json for 2 gaia-central revision(s) a=NPOTB ======== https://hg.mozilla.org/integration/gaia-central/rev/239f22974aae Author: Francisco Borja Salguero Castellano Desc: Merge pull request #11889 from borjasalguero/madrid_getdisplayinfo Bug 900443 - [SMS] Remove repeated request to Contacts API when retrievi... ======== https://hg.mozilla.org/integration/gaia-central/rev/d0a61a8248a6 Author: borjasalguero Desc: Bug 900443 - [SMS] Remove repeated request to Contacts API when retrieving a contact from 'Contacts' activity. r=julienw --- b2g/config/gaia.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/b2g/config/gaia.json b/b2g/config/gaia.json index bf2f2e364c8f..555bb6e6df0d 100644 --- a/b2g/config/gaia.json +++ b/b2g/config/gaia.json @@ -1,4 +1,4 @@ { - "revision": "98f191869b0cc294923f7d4039b4e6bc292f26cc", + "revision": "239f22974aae6ee1da6760178dbe9057961f0fa1", "repo_path": "/integration/gaia-central" } From 30c334eb9b3a3fbc6e0589092ef1d0aa7102ca43 Mon Sep 17 00:00:00 2001 From: Gaia Pushbot Date: Thu, 19 Sep 2013 06:10:24 -0700 Subject: [PATCH 07/10] Bumping gaia.json for 2 gaia-central revision(s) a=NPOTB ======== https://hg.mozilla.org/integration/gaia-central/rev/33d22cba7641 Author: Arnau Desc: Merge pull request #11860 from rnowm/821673 Bug 821673 - Redesign back, menu and close buttons ======== https://hg.mozilla.org/integration/gaia-central/rev/1b57a5c8be1d Author: Arnau Desc: Bug 821673 - Redesign back, menu and close buttons --- b2g/config/gaia.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/b2g/config/gaia.json b/b2g/config/gaia.json index 555bb6e6df0d..af0920a7bf75 100644 --- a/b2g/config/gaia.json +++ b/b2g/config/gaia.json @@ -1,4 +1,4 @@ { - "revision": "239f22974aae6ee1da6760178dbe9057961f0fa1", + "revision": "33d22cba7641114fbc9804399208138fae6de2be", "repo_path": "/integration/gaia-central" } From 6b5f08c50b74016038cf43a51e8f7143fdcd7adf Mon Sep 17 00:00:00 2001 From: Kartikaya Gupta Date: Thu, 19 Sep 2013 10:31:28 -0400 Subject: [PATCH 08/10] Bug 909525 - Prevent the scroll offset being picked up from the wrong element in some cases. r=botond,tn In some cases pages from the bfcache can get displayed to the screen without going through layout. In these cases, the element associated with the ROOT_SCROLL_ID may be from a different document, so it is inadvisable to use that element's scroll position as if it were the current document's scroll position. Doing so can lead to incorrect behaviour. This patch fixes such a case. --- dom/ipc/TabChild.cpp | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/dom/ipc/TabChild.cpp b/dom/ipc/TabChild.cpp index 19c6d50393c1..7be72d21e2dc 100644 --- a/dom/ipc/TabChild.cpp +++ b/dom/ipc/TabChild.cpp @@ -332,28 +332,37 @@ TabChild::HandleEvent(nsIDOMEvent* aEvent) if (!nsLayoutUtils::FindIDFor(content, &viewId)) return NS_ERROR_UNEXPECTED; - scrollFrame = nsLayoutUtils::FindScrollableFrameFor(viewId); - if (scrollFrame) { - CSSIntPoint scrollOffset = scrollFrame->GetScrollPositionCSSPixels(); + // Note that we cannot use FindScrollableFrameFor(ROOT_SCROLL_ID) because + // it might return the root element from a different page in the case where + // that page is in the bfcache and this page is not run through layout + // before being drawn to the screen. Hence the code blocks below treat + // ROOT_SCROLL_ID separately from the non-ROOT_SCROLL_ID case. + CSSIntPoint scrollOffset; + if (viewId != FrameMetrics::ROOT_SCROLL_ID) { + scrollFrame = nsLayoutUtils::FindScrollableFrameFor(viewId); + if (!scrollFrame) { + return NS_OK; + } + scrollOffset = scrollFrame->GetScrollPositionCSSPixels(); + } else { // For the root frame, we store the last metrics, including the last // scroll offset, sent by APZC. (This is updated in ProcessUpdateFrame()). // We use this here to avoid sending APZC back a scroll event that // originally came from APZC (besides being unnecessary, the event might // be slightly out of date by the time it reaches APZC). // We should probably do this for subframes, too. - if (viewId == FrameMetrics::ROOT_SCROLL_ID) { - if (RoundedToInt(mLastMetrics.mScrollOffset) == scrollOffset) - return NS_OK; - else - // Update the last scroll offset now, otherwise RecvUpdateDimensions() - // might trigger a scroll to the old offset before RecvUpdateFrame() - // gets a chance to update it. - mLastMetrics.mScrollOffset = scrollOffset; + utils->GetScrollXY(false, &scrollOffset.x, &scrollOffset.y); + if (RoundedToInt(mLastMetrics.mScrollOffset) == scrollOffset) { + return NS_OK; } - SendUpdateScrollOffset(presShellId, viewId, scrollOffset); + // Update the last scroll offset now, otherwise RecvUpdateDimensions() + // might trigger a scroll to the old offset before RecvUpdateFrame() + // gets a chance to update it. + mLastMetrics.mScrollOffset = scrollOffset; } + SendUpdateScrollOffset(presShellId, viewId, scrollOffset); } return NS_OK; From 74cb0818947e8458174998321d399c85dbc373ab Mon Sep 17 00:00:00 2001 From: Gaia Pushbot Date: Thu, 19 Sep 2013 08:00:23 -0700 Subject: [PATCH 09/10] Bumping gaia.json for 1 gaia-central revision(s) a=NPOTB ======== https://hg.mozilla.org/integration/gaia-central/rev/f8a6680334ee Author: Corey Frang Desc: Bug 917956 - [Clock] Timer spinner allows for out-of-bound input - r=jugglinmike - The "upper" limit of the select should be the length of values - 1 (not the length) --- b2g/config/gaia.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/b2g/config/gaia.json b/b2g/config/gaia.json index af0920a7bf75..121f63b5084e 100644 --- a/b2g/config/gaia.json +++ b/b2g/config/gaia.json @@ -1,4 +1,4 @@ { - "revision": "33d22cba7641114fbc9804399208138fae6de2be", + "revision": "f8a6680334eedbfb6e7177aee63430ce4caa2b6b", "repo_path": "/integration/gaia-central" } From 57cd37095ab87d27127f8d2e4ebddd25f26f8b38 Mon Sep 17 00:00:00 2001 From: Gaia Pushbot Date: Thu, 19 Sep 2013 08:10:22 -0700 Subject: [PATCH 10/10] Bumping gaia.json for 4 gaia-central revision(s) a=NPOTB ======== https://hg.mozilla.org/integration/gaia-central/rev/ca3e0c37006f Author: Francisco Borja Salguero Castellano Desc: Merge pull request #12312 from borjasalguero/followup_sms Bug 918302 - [Followup 900443][SMS] Add a robust check when retrieving a... ======== https://hg.mozilla.org/integration/gaia-central/rev/99c1b41313cd Author: borjasalguero Desc: Bug 918302 - [Followup 900443][SMS] Add a robust check when retrieving a contact from activity. r=julienw ======== https://hg.mozilla.org/integration/gaia-central/rev/d6876efaab51 Author: Fernando Campo Desc: Merge pull request #12270 from fcampo/BT-exportVcard-887534 Bug 887534 - [US] Send contact as a VCARD via bluetooth (r=borjasalguero) ======== https://hg.mozilla.org/integration/gaia-central/rev/a258d8fafed8 Author: Fernando Campo Desc: Bug 887534 - [US] Send contact as a VCARD via bluetooth ------------------------------------------------------- Create bt.js and use it for bluetooth call Add error messages, seems to work, error related to other bugs Fixing activity parameters Correct path for file Getting the file from sdcard Adding log sfor debug More logs, seems to work now last changes, working now, need to clean up code Cleaning up Refactor and final cleanup Adding tests --- b2g/config/gaia.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/b2g/config/gaia.json b/b2g/config/gaia.json index 121f63b5084e..7116cd06ed72 100644 --- a/b2g/config/gaia.json +++ b/b2g/config/gaia.json @@ -1,4 +1,4 @@ { - "revision": "f8a6680334eedbfb6e7177aee63430ce4caa2b6b", + "revision": "ca3e0c37006fb38e756288cc87b67834ad88a9ad", "repo_path": "/integration/gaia-central" }