wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge m-c to mozilla-inbound

Browse Source
This commit is contained in:
Carsten "Tomcat" Book 2014-09-05 12:17:08 +02:00
commit ee88b5c972
10 changed files with 88 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
dom/icc/Assertions.cpp
View File

@ -1,49 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/dom/MozIccBinding.h"
#include "nsIIccProvider.h"
namespace mozilla {
namespace dom {
#define ASSERT_ICC_CARD_STATE_EQUALITY(webidlState, xpidlState) \
static_assert(static_cast<uint32_t>(IccCardState::webidlState) == nsIIccProvider::xpidlState, \
"IccCardState::" #webidlState " should equal to nsIIccProvider::" #xpidlState)
ASSERT_ICC_CARD_STATE_EQUALITY(Unknown, CARD_STATE_UNKNOWN);
ASSERT_ICC_CARD_STATE_EQUALITY(Ready, CARD_STATE_READY);
ASSERT_ICC_CARD_STATE_EQUALITY(PinRequired, CARD_STATE_PIN_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(PukRequired, CARD_STATE_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(PermanentBlocked, CARD_STATE_PERMANENT_BLOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(PersonalizationInProgress, CARD_STATE_PERSONALIZATION_IN_PROGRESS);
ASSERT_ICC_CARD_STATE_EQUALITY(PersonalizationReady, CARD_STATE_PERSONALIZATION_READY);
ASSERT_ICC_CARD_STATE_EQUALITY(NetworkLocked, CARD_STATE_NETWORK_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(NetworkSubsetLocked, CARD_STATE_NETWORK_SUBSET_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(CorporateLocked, CARD_STATE_CORPORATE_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(ServiceProviderLocked, CARD_STATE_SERVICE_PROVIDER_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(SimPersonalizationLocked, CARD_STATE_SIM_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(NetworkPukRequired, CARD_STATE_NETWORK_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(NetworkSubsetPukRequired, CARD_STATE_NETWORK_SUBSET_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(CorporatePukRequired, CARD_STATE_CORPORATE_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(ServiceProviderPukRequired, CARD_STATE_SERVICE_PROVIDER_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(SimPersonalizationPukRequired, CARD_STATE_SIM_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(Network1Locked, CARD_STATE_NETWORK1_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(Network2Locked, CARD_STATE_NETWORK2_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(HrpdNetworkLocked, CARD_STATE_HRPD_NETWORK_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(RuimCorporateLocked, CARD_STATE_RUIM_CORPORATE_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(RuimServiceProviderLocked, CARD_STATE_RUIM_SERVICE_PROVIDER_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(RuimPersonalizationLocked, CARD_STATE_RUIM_LOCKED);
ASSERT_ICC_CARD_STATE_EQUALITY(Network1PukRequired, CARD_STATE_NETWORK1_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(Network2PukRequired, CARD_STATE_NETWORK2_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(HrpdNetworkPukRequired, CARD_STATE_HRPD_NETWORK_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(RuimCorporatePukRequired, CARD_STATE_RUIM_CORPORATE_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(RuimServiceProviderPukRequired, CARD_STATE_RUIM_SERVICE_PROVIDER_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(RuimPersonalizationPukRequired, CARD_STATE_RUIM_PUK_REQUIRED);
ASSERT_ICC_CARD_STATE_EQUALITY(Illegal, CARD_STATE_ILLEGAL);
#undef ASSERT_ICC_CARD_STATE_EQUALITY
} // namespace dom
} // namespace mozilla

19
dom/icc/Icc.cpp
View File

@ -100,20 +100,19 @@ Icc::GetIccInfo() const
return iccInfo.forget();
}
Nullable<IccCardState>
Icc::GetCardState() const
void
Icc::GetCardState(nsString& aCardState) const
{
Nullable<IccCardState> result;
aCardState.SetIsVoid(true);
uint32_t cardState = nsIIccProvider::CARD_STATE_UNDETECTED;
if (mProvider &&
NS_SUCCEEDED(mProvider->GetCardState(mClientId, &cardState)) &&
cardState != nsIIccProvider::CARD_STATE_UNDETECTED) {
MOZ_ASSERT(cardState < static_cast<uint32_t>(IccCardState::EndGuard_));
result.SetValue(static_cast<IccCardState>(cardState));
if (!mProvider) {
return;
}
return result;
nsresult rv = mProvider->GetCardState(mClientId, aCardState);
if (NS_FAILED(rv)) {
aCardState.SetIsVoid(true);
}
}
void

5
dom/icc/Icc.h
View File

@ -5,7 +5,6 @@
#ifndef mozilla_dom_Icc_h
#define mozilla_dom_Icc_h
#include "mozilla/dom/MozIccBinding.h" // For IccCardState
#include "mozilla/DOMEventTargetHelper.h"
#include "nsIIccProvider.h"
@ -50,8 +49,8 @@ public:
already_AddRefed<nsIDOMMozIccInfo>
GetIccInfo() const;
Nullable<IccCardState>
GetCardState() const;
void
GetCardState(nsString& aCardState) const;
void
SendStkResponse(const JSContext* aCx, JS::Handle<JS::Value> aCommand,

38
dom/icc/interfaces/nsIIccProvider.idl
View File

@ -20,43 +20,9 @@ interface nsIIccListener : nsISupports
/**
* XPCOM component (in the content process) that provides the ICC information.
*/
[scriptable, uuid(aa404b6e-fcfa-4bd2-bc46-e4e94b603ca7)]
[scriptable, uuid(7c67ab92-52a3-4e11-995c-c0ad2f66c4cb)]
interface nsIIccProvider : nsISupports
{
// MUST match enum IccCardState in MozIcc.webidl!
const unsigned long CARD_STATE_UNKNOWN = 0;
const unsigned long CARD_STATE_READY = 1;
const unsigned long CARD_STATE_PIN_REQUIRED = 2;
const unsigned long CARD_STATE_PUK_REQUIRED = 3;
const unsigned long CARD_STATE_PERMANENT_BLOCKED = 4;
const unsigned long CARD_STATE_PERSONALIZATION_IN_PROGRESS = 5;
const unsigned long CARD_STATE_PERSONALIZATION_READY = 6;
const unsigned long CARD_STATE_NETWORK_LOCKED = 7;
const unsigned long CARD_STATE_NETWORK_SUBSET_LOCKED = 8;
const unsigned long CARD_STATE_CORPORATE_LOCKED = 9;
const unsigned long CARD_STATE_SERVICE_PROVIDER_LOCKED = 10;
const unsigned long CARD_STATE_SIM_LOCKED = 11;
const unsigned long CARD_STATE_NETWORK_PUK_REQUIRED = 12;
const unsigned long CARD_STATE_NETWORK_SUBSET_PUK_REQUIRED = 13;
const unsigned long CARD_STATE_CORPORATE_PUK_REQUIRED = 14;
const unsigned long CARD_STATE_SERVICE_PROVIDER_PUK_REQUIRED = 15;
const unsigned long CARD_STATE_SIM_PUK_REQUIRED = 16;
const unsigned long CARD_STATE_NETWORK1_LOCKED = 17;
const unsigned long CARD_STATE_NETWORK2_LOCKED = 18;
const unsigned long CARD_STATE_HRPD_NETWORK_LOCKED = 19;
const unsigned long CARD_STATE_RUIM_CORPORATE_LOCKED = 20;
const unsigned long CARD_STATE_RUIM_SERVICE_PROVIDER_LOCKED = 21;
const unsigned long CARD_STATE_RUIM_LOCKED = 22;
const unsigned long CARD_STATE_NETWORK1_PUK_REQUIRED = 23;
const unsigned long CARD_STATE_NETWORK2_PUK_REQUIRED = 24;
const unsigned long CARD_STATE_HRPD_NETWORK_PUK_REQUIRED = 25;
const unsigned long CARD_STATE_RUIM_CORPORATE_PUK_REQUIRED = 26;
const unsigned long CARD_STATE_RUIM_SERVICE_PROVIDER_PUK_REQUIRED = 27;
const unsigned long CARD_STATE_RUIM_PUK_REQUIRED = 28;
const unsigned long CARD_STATE_ILLEGAL = 29;
const unsigned long CARD_STATE_UNDETECTED = 4294967295; // UINT32_MAX
/**
* Called when a content process registers receiving unsolicited messages from
* RadioInterfaceLayer in the chrome process. Only a content process that has
@ -73,7 +39,7 @@ interface nsIIccProvider : nsISupports
/**
* Card State
*/
unsigned long getCardState(in unsigned long clientId);
DOMString getCardState(in unsigned long clientId);
/**
* STK interfaces.

4
dom/icc/moz.build
View File

@ -11,10 +11,6 @@ EXPORTS.mozilla.dom += [
'IccManager.h',
]
UNIFIED_SOURCES += [
'Assertions.cpp',
]
SOURCES += [
'Icc.cpp',
'IccListener.cpp',

2
dom/system/gonk/RILContentHelper.js
View File

@ -284,7 +284,7 @@ function RILContentHelper() {
this.voicemailStatuses = [];
for (let clientId = 0; clientId < this.numClients; clientId++) {
this.rilContexts[clientId] = {
cardState: Ci.nsIIccProvider.CARD_STATE_UNKNOWN,
cardState: RIL.GECKO_CARDSTATE_UNKNOWN,
iccInfo: null
};

8
dom/system/gonk/RadioInterfaceLayer.js
View File

@ -559,8 +559,8 @@ XPCOMUtils.defineLazyGetter(this, "gRadioEnabledController", function() {
_isCardPresentAtClient: function(clientId) {
let cardState = _ril.getRadioInterface(clientId).rilContext.cardState;
return cardState !== Ci.nsIIccProvider.CARD_STATE_UNDETECTED &&
cardState !== Ci.nsIIccProvider.CARD_STATE_UNKNOWN;
return cardState !== RIL.GECKO_CARDSTATE_UNDETECTED &&
cardState !== RIL.GECKO_CARDSTATE_UNKNOWN;
},
_isRadioAbleToEnableAtClient: function(clientId, numCards) {
@ -1873,7 +1873,7 @@ function RadioInterface(aClientId, aWorkerMessenger) {
aWorkerMessenger.registerClient(aClientId, this);
this.rilContext = {
cardState: Ci.nsIIccProvider.CARD_STATE_UNKNOWN,
cardState: RIL.GECKO_CARDSTATE_UNKNOWN,
iccInfo: null,
imsi: null
};
@ -3713,7 +3713,7 @@ RadioInterface.prototype = {
} else if (radioState == RIL.GECKO_RADIOSTATE_DISABLED) {
if (DEBUG) this.debug("Error! Radio is disabled when sending SMS.");
errorCode = Ci.nsIMobileMessageCallback.RADIO_DISABLED_ERROR;
} else if (this.rilContext.cardState != Ci.nsIIccProvider.CARD_STATE_READY) {
} else if (this.rilContext.cardState != "ready") {
if (DEBUG) this.debug("Error! SIM card is not ready when sending SMS.");
errorCode = Ci.nsIMobileMessageCallback.NO_SIM_CARD_ERROR;
}

67
dom/system/gonk/ril_consts.js
View File

@ -2487,40 +2487,38 @@ this.GECKO_RADIOSTATE_ENABLED = "enabled";
this.GECKO_RADIOSTATE_DISABLING = "disabling";
this.GECKO_RADIOSTATE_DISABLED = "disabled";
// Only used in ril_worker.js
this.GECKO_CARDSTATE_UNINITIALIZED = 4294967294; // UINT32_MAX - 1
// See nsIIccProvider::CARD_STATE_*
this.GECKO_CARDSTATE_UNDETECTED = 4294967295; // UINT32_MAX
this.GECKO_CARDSTATE_UNKNOWN = 0;
this.GECKO_CARDSTATE_READY = 1;
this.GECKO_CARDSTATE_PIN_REQUIRED = 2;
this.GECKO_CARDSTATE_PUK_REQUIRED = 3;
this.GECKO_CARDSTATE_PERMANENT_BLOCKED = 4;
this.GECKO_CARDSTATE_PERSONALIZATION_IN_PROGRESS = 5;
this.GECKO_CARDSTATE_PERSONALIZATION_READY = 6;
this.GECKO_CARDSTATE_NETWORK_LOCKED = 7;
this.GECKO_CARDSTATE_NETWORK_SUBSET_LOCKED = 8;
this.GECKO_CARDSTATE_CORPORATE_LOCKED = 9;
this.GECKO_CARDSTATE_SERVICE_PROVIDER_LOCKED = 10;
this.GECKO_CARDSTATE_SIM_LOCKED = 11;
this.GECKO_CARDSTATE_NETWORK_PUK_REQUIRED = 12;
this.GECKO_CARDSTATE_NETWORK_SUBSET_PUK_REQUIRED = 13;
this.GECKO_CARDSTATE_CORPORATE_PUK_REQUIRED = 14;
this.GECKO_CARDSTATE_SERVICE_PROVIDER_PUK_REQUIRED = 15;
this.GECKO_CARDSTATE_SIM_PUK_REQUIRED = 16;
this.GECKO_CARDSTATE_NETWORK1_LOCKED = 17;
this.GECKO_CARDSTATE_NETWORK2_LOCKED = 18;
this.GECKO_CARDSTATE_HRPD_NETWORK_LOCKED = 19;
this.GECKO_CARDSTATE_RUIM_CORPORATE_LOCKED = 20;
this.GECKO_CARDSTATE_RUIM_SERVICE_PROVIDER_LOCKED = 21;
this.GECKO_CARDSTATE_RUIM_LOCKED = 22;
this.GECKO_CARDSTATE_NETWORK1_PUK_REQUIRED = 23;
this.GECKO_CARDSTATE_NETWORK2_PUK_REQUIRED = 24;
this.GECKO_CARDSTATE_HRPD_NETWORK_PUK_REQUIRED = 25;
this.GECKO_CARDSTATE_RUIM_CORPORATE_PUK_REQUIRED = 26;
this.GECKO_CARDSTATE_RUIM_SERVICE_PROVIDER_PUK_REQUIRED = 27;
this.GECKO_CARDSTATE_RUIM_PUK_REQUIRED = 28;
this.GECKO_CARDSTATE_ILLEGAL = 29;
this.GECKO_CARDSTATE_UNINITIALIZED = "uninitialized";
this.GECKO_CARDSTATE_UNDETECTED = null;
this.GECKO_CARDSTATE_ILLEGAL = "illegal";
this.GECKO_CARDSTATE_UNKNOWN = "unknown";
this.GECKO_CARDSTATE_PIN_REQUIRED = "pinRequired";
this.GECKO_CARDSTATE_PUK_REQUIRED = "pukRequired";
this.GECKO_CARDSTATE_PERSONALIZATION_IN_PROGRESS = "personalizationInProgress";
this.GECKO_CARDSTATE_PERSONALIZATION_READY = "personalizationReady";
this.GECKO_CARDSTATE_NETWORK_LOCKED = "networkLocked";
this.GECKO_CARDSTATE_NETWORK_SUBSET_LOCKED = "networkSubsetLocked";
this.GECKO_CARDSTATE_NETWORK1_LOCKED = "network1Locked";
this.GECKO_CARDSTATE_NETWORK2_LOCKED = "network2Locked";
this.GECKO_CARDSTATE_HRPD_NETWORK_LOCKED = "hrpdNetworkLocked";
this.GECKO_CARDSTATE_CORPORATE_LOCKED = "corporateLocked";
this.GECKO_CARDSTATE_SERVICE_PROVIDER_LOCKED = "serviceProviderLocked";
this.GECKO_CARDSTATE_SIM_LOCKED = "simPersonalizationLock";
this.GECKO_CARDSTATE_RUIM_CORPORATE_LOCKED = "ruimCorporateLocked";
this.GECKO_CARDSTATE_RUIM_SERVICE_PROVIDER_LOCKED = "ruimServiceProviderLocked";
this.GECKO_CARDSTATE_RUIM_LOCKED = "ruimPersonalizationLock";
this.GECKO_CARDSTATE_NETWORK_PUK_REQUIRED = "networkPukRequired";
this.GECKO_CARDSTATE_NETWORK_SUBSET_PUK_REQUIRED = "networkSubsetPukRequired";
this.GECKO_CARDSTATE_NETWORK1_PUK_REQUIRED = "network1PukRequired";
this.GECKO_CARDSTATE_NETWORK2_PUK_REQUIRED = "network2PukRequired";
this.GECKO_CARDSTATE_HRPD_NETWORK_PUK_REQUIRED = "hrpdNetworkPukRequired";
this.GECKO_CARDSTATE_CORPORATE_PUK_REQUIRED = "corporatePukRequired";
this.GECKO_CARDSTATE_SERVICE_PROVIDER_PUK_REQUIRED = "serviceProviderPukRequired";
this.GECKO_CARDSTATE_SIM_PUK_REQUIRED = "simPersonalizationPukRequired";
this.GECKO_CARDSTATE_RUIM_CORPORATE_PUK_REQUIRED = "ruimCorporatePukRequired";
this.GECKO_CARDSTATE_RUIM_SERVICE_PROVIDER_PUK_REQUIRED = "ruimServiceProviderPukRequired";
this.GECKO_CARDSTATE_RUIM_PUK_REQUIRED = "ruimPersonalizationPukRequired";
this.GECKO_CARDSTATE_READY = "ready";
this.GECKO_CARDSTATE_PERMANENT_BLOCKED = "permanentBlocked";
this.GECKO_CARDLOCK_PIN = "pin";
this.GECKO_CARDLOCK_PIN2 = "pin2";
@ -2558,7 +2556,6 @@ PERSONSUBSTATE[CARD_PERSOSUBSTATE_SIM_NETWORK_PUK] = GECKO_CARDSTATE_NETWORK_PUK
PERSONSUBSTATE[CARD_PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK] = GECKO_CARDSTATE_NETWORK_SUBSET_PUK_REQUIRED;
PERSONSUBSTATE[CARD_PERSOSUBSTATE_SIM_CORPORATE_PUK] = GECKO_CARDSTATE_CORPORATE_PUK_REQUIRED;
PERSONSUBSTATE[CARD_PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK] = GECKO_CARDSTATE_SERVICE_PROVIDER_PUK_REQUIRED;
PERSONSUBSTATE[CARD_PERSOSUBSTATE_SIM_SIM_PUK] = GECKO_CARDSTATE_SIM_PUK_REQUIRED;
PERSONSUBSTATE[CARD_PERSOSUBSTATE_RUIM_NETWORK1] = GECKO_CARDSTATE_NETWORK1_LOCKED;
PERSONSUBSTATE[CARD_PERSOSUBSTATE_RUIM_NETWORK2] = GECKO_CARDSTATE_NETWORK2_LOCKED;
PERSONSUBSTATE[CARD_PERSOSUBSTATE_RUIM_HRPD] = GECKO_CARDSTATE_HRPD_NETWORK_LOCKED;

72
dom/system/gonk/tests/test_ril_worker_icc_CardState.js
View File

@ -33,65 +33,45 @@ add_test(function test_personalization_state() {
// Test GSM personalization state.
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_NETWORK,
Ci.nsIIccProvider.CARD_STATE_NETWORK_LOCKED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_NETWORK_SUBSET,
Ci.nsIIccProvider.CARD_STATE_NETWORK_SUBSET_LOCKED);
GECKO_CARDSTATE_NETWORK_LOCKED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_CORPORATE,
Ci.nsIIccProvider.CARD_STATE_CORPORATE_LOCKED);
GECKO_CARDSTATE_CORPORATE_LOCKED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_SERVICE_PROVIDER,
Ci.nsIIccProvider.CARD_STATE_SERVICE_PROVIDER_LOCKED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_SIM,
Ci.nsIIccProvider.CARD_STATE_SIM_LOCKED);
GECKO_CARDSTATE_SERVICE_PROVIDER_LOCKED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_NETWORK_PUK,
Ci.nsIIccProvider.CARD_STATE_NETWORK_PUK_REQUIRED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK,
Ci.nsIIccProvider.CARD_STATE_NETWORK_SUBSET_PUK_REQUIRED);
GECKO_CARDSTATE_NETWORK_PUK_REQUIRED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_CORPORATE_PUK,
Ci.nsIIccProvider.CARD_STATE_CORPORATE_PUK_REQUIRED);
GECKO_CARDSTATE_CORPORATE_PUK_REQUIRED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK,
Ci.nsIIccProvider.CARD_STATE_SERVICE_PROVIDER_PUK_REQUIRED);
testPersonalization(false, CARD_PERSOSUBSTATE_SIM_SIM_PUK,
Ci.nsIIccProvider.CARD_STATE_SIM_PUK_REQUIRED);
testPersonalization(false, CARD_PERSOSUBSTATE_UNKNOWN,
Ci.nsIIccProvider.CARD_STATE_UNKNOWN);
testPersonalization(false, CARD_PERSOSUBSTATE_IN_PROGRESS,
Ci.nsIIccProvider.CARD_STATE_PERSONALIZATION_IN_PROGRESS);
GECKO_CARDSTATE_SERVICE_PROVIDER_PUK_REQUIRED);
testPersonalization(false, CARD_PERSOSUBSTATE_READY,
Ci.nsIIccProvider.CARD_STATE_PERSONALIZATION_READY);
GECKO_CARDSTATE_PERSONALIZATION_READY);
// Test CDMA personalization state.
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_NETWORK1,
Ci.nsIIccProvider.CARD_STATE_NETWORK1_LOCKED);
GECKO_CARDSTATE_NETWORK1_LOCKED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_NETWORK2,
Ci.nsIIccProvider.CARD_STATE_NETWORK2_LOCKED);
GECKO_CARDSTATE_NETWORK2_LOCKED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_HRPD,
Ci.nsIIccProvider.CARD_STATE_HRPD_NETWORK_LOCKED);
GECKO_CARDSTATE_HRPD_NETWORK_LOCKED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_CORPORATE,
Ci.nsIIccProvider.CARD_STATE_RUIM_CORPORATE_LOCKED);
GECKO_CARDSTATE_RUIM_CORPORATE_LOCKED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_SERVICE_PROVIDER,
Ci.nsIIccProvider.CARD_STATE_RUIM_SERVICE_PROVIDER_LOCKED);
GECKO_CARDSTATE_RUIM_SERVICE_PROVIDER_LOCKED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_RUIM,
Ci.nsIIccProvider.CARD_STATE_RUIM_LOCKED);
GECKO_CARDSTATE_RUIM_LOCKED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_NETWORK1_PUK,
Ci.nsIIccProvider.CARD_STATE_NETWORK1_PUK_REQUIRED);
GECKO_CARDSTATE_NETWORK1_PUK_REQUIRED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_NETWORK2_PUK,
Ci.nsIIccProvider.CARD_STATE_NETWORK2_PUK_REQUIRED);
GECKO_CARDSTATE_NETWORK2_PUK_REQUIRED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_HRPD_PUK,
Ci.nsIIccProvider.CARD_STATE_HRPD_NETWORK_PUK_REQUIRED);
GECKO_CARDSTATE_HRPD_NETWORK_PUK_REQUIRED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_CORPORATE_PUK,
Ci.nsIIccProvider.CARD_STATE_RUIM_CORPORATE_PUK_REQUIRED);
GECKO_CARDSTATE_RUIM_CORPORATE_PUK_REQUIRED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK,
Ci.nsIIccProvider.CARD_STATE_RUIM_SERVICE_PROVIDER_PUK_REQUIRED);
GECKO_CARDSTATE_RUIM_SERVICE_PROVIDER_PUK_REQUIRED);
testPersonalization(true, CARD_PERSOSUBSTATE_RUIM_RUIM_PUK,
Ci.nsIIccProvider.CARD_STATE_RUIM_PUK_REQUIRED);
testPersonalization(true, CARD_PERSOSUBSTATE_UNKNOWN,
Ci.nsIIccProvider.CARD_STATE_UNKNOWN);
testPersonalization(true, CARD_PERSOSUBSTATE_IN_PROGRESS,
Ci.nsIIccProvider.CARD_STATE_PERSONALIZATION_IN_PROGRESS);
testPersonalization(true, CARD_PERSOSUBSTATE_READY,
Ci.nsIIccProvider.CARD_STATE_PERSONALIZATION_READY);
GECKO_CARDSTATE_RUIM_PUK_REQUIRED);
run_next_test();
});
@ -121,17 +101,17 @@ add_test(function test_card_app_state() {
}
testCardAppState(CARD_APPSTATE_ILLEGAL,
Ci.nsIIccProvider.CARD_STATE_ILLEGAL);
GECKO_CARDSTATE_ILLEGAL);
testCardAppState(CARD_APPSTATE_PIN,
Ci.nsIIccProvider.CARD_STATE_PIN_REQUIRED);
GECKO_CARDSTATE_PIN_REQUIRED);
testCardAppState(CARD_APPSTATE_PUK,
Ci.nsIIccProvider.CARD_STATE_PUK_REQUIRED);
GECKO_CARDSTATE_PUK_REQUIRED);
testCardAppState(CARD_APPSTATE_READY,
Ci.nsIIccProvider.CARD_STATE_READY);
GECKO_CARDSTATE_READY);
testCardAppState(CARD_APPSTATE_UNKNOWN,
Ci.nsIIccProvider.CARD_STATE_UNKNOWN);
GECKO_CARDSTATE_UNKNOWN);
testCardAppState(CARD_APPSTATE_DETECTED,
Ci.nsIIccProvider.CARD_STATE_UNKNOWN);
GECKO_CARDSTATE_UNKNOWN);
run_next_test();
});
@ -159,7 +139,7 @@ add_test(function test_icc_permanent_blocked() {
};
ril._processICCStatus(iccStatus);
do_check_eq(ril.cardState, Ci.nsIIccProvider.CARD_STATE_PERMANENT_BLOCKED);
do_check_eq(ril.cardState, GECKO_CARDSTATE_PERMANENT_BLOCKED);
}
testPermanentBlocked(1,

63
dom/webidl/MozIcc.webidl
View File

@ -4,57 +4,6 @@
interface MozIccInfo;
enum IccCardState {
"unknown", // ICC card state is either not yet reported from modem or in an
// unknown state.
"ready",
"pinRequired",
"pukRequired",
"permanentBlocked",
/**
* Personalization States
*/
"personalizationInProgress",
"personalizationReady",
// SIM Personalization States.
"networkLocked",
"networkSubsetLocked",
"corporateLocked",
"serviceProviderLocked",
"simPersonalizationLocked",
"networkPukRequired",
"networkSubsetPukRequired",
"corporatePukRequired",
"serviceProviderPukRequired",
"simPersonalizationPukRequired",
// RUIM Personalization States.
"network1Locked",
"network2Locked",
"hrpdNetworkLocked",
"ruimCorporateLocked",
"ruimServiceProviderLocked",
"ruimPersonalizationLocked",
"network1PukRequired",
"network2PukRequired",
"hrpdNetworkPukRequired",
"ruimCorporatePukRequired",
"ruimServiceProviderPukRequired",
"ruimPersonalizationPukRequired",
/**
* Additional States.
*/
"illegal" // See Bug 916000. An owed pay card will be rejected by the network
// and fall in this state.
};
[Pref="dom.icc.enabled"]
interface MozIcc : EventTarget
{
@ -80,11 +29,21 @@ interface MozIcc : EventTarget
/**
* Indicates the state of the device's ICC.
*
* Possible values: 'illegal', 'unknown', 'pinRequired', 'pukRequired',
* 'personalizationInProgress', 'networkLocked', 'network1Locked',
* 'network2Locked', 'hrpdNetworkLocked', 'corporateLocked',
* 'serviceProviderLocked', 'ruimCorporateLocked', 'ruimServiceProviderLocked',
* 'networkPukRequired', 'network1PukRequired', 'network2PukRequired',
* 'hrpdNetworkPukRequired', 'corporatePukRequired',
* 'serviceProviderPukRequired', 'ruimCorporatePukRequired',
* 'ruimServiceProviderPukRequired', 'personalizationReady', 'ready',
* 'permanentBlocked'.
*
* Once the ICC becomes undetectable, cardstatechange event will be notified.
* Also, the attribute is set to null and this MozIcc object becomes invalid.
* Calling asynchronous functions raises exception then.
*/
readonly attribute IccCardState? cardState;
readonly attribute DOMString? cardState;
/**
* The 'cardstatechange' event is notified when the 'cardState' attribute