diff options
Diffstat (limited to 'data')
29 files changed, 5953 insertions, 0 deletions
diff --git a/data/patches/0001-Bug-1013064-part-1-prompt-for-master-password-unlock.patch b/data/patches/0001-Bug-1013064-part-1-prompt-for-master-password-unlock.patch new file mode 100644 index 0000000..1880604 --- /dev/null +++ b/data/patches/0001-Bug-1013064-part-1-prompt-for-master-password-unlock.patch @@ -0,0 +1,60 @@ +From 18f9d132020afee6004e63c9006245e4d3b04e18 Mon Sep 17 00:00:00 2001 +From: Mark Hammond <mhammond@skippinet.com.au> +Date: Wed, 11 Jun 2014 17:34:24 +1000 +Subject: Bug 1013064 (part 1) - prompt for master-password unlock when + interacting with about:accounts. r=ttaubert + +--- + browser/base/content/aboutaccounts/aboutaccounts.js | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/browser/base/content/aboutaccounts/aboutaccounts.js b/browser/base/content/aboutaccounts/aboutaccounts.js +index 5cceae15..af31be9 100644 +--- a/browser/base/content/aboutaccounts/aboutaccounts.js ++++ b/browser/base/content/aboutaccounts/aboutaccounts.js +@@ -7,16 +7,19 @@ + const {classes: Cc, interfaces: Ci, utils: Cu} = Components; + + Cu.import("resource://gre/modules/Services.jsm"); + Cu.import("resource://gre/modules/FxAccounts.jsm"); + + let fxAccountsCommon = {}; + Cu.import("resource://gre/modules/FxAccountsCommon.js", fxAccountsCommon); + ++// for master-password utilities ++Cu.import("resource://services-sync/util.js"); ++ + const PREF_LAST_FXA_USER = "identity.fxaccounts.lastSignedInUserHash"; + const PREF_SYNC_SHOW_CUSTOMIZATION = "services.sync.ui.showCustomizationDialog"; + + const OBSERVER_TOPICS = [ + fxAccountsCommon.ONVERIFIED_NOTIFICATION, + fxAccountsCommon.ONLOGOUT_NOTIFICATION, + ]; + +@@ -99,16 +102,22 @@ let wrapper = { + .wrappedJSObject; + + // Don't show about:accounts with FxA disabled. + if (!weave.fxAccountsEnabled) { + document.body.remove(); + return; + } + ++ // If a master-password is enabled, we want to encourage the user to ++ // unlock it. Things still work if not, but the user will probably need ++ // to re-auth next startup (in which case we will get here again and ++ // re-prompt) ++ Utils.ensureMPUnlocked(); ++ + let iframe = document.getElementById("remote"); + this.iframe = iframe; + iframe.addEventListener("load", this); + + try { + iframe.src = url || fxAccounts.getAccountsSignUpURI(); + } catch (e) { + error("Couldn't init Firefox Account wrapper: " + e.message); +-- +1.8.3.msysgit.0 + diff --git a/data/patches/0002-Bug-1013064-part-2-Store-sensitive-FxA-credentials-i.patch b/data/patches/0002-Bug-1013064-part-2-Store-sensitive-FxA-credentials-i.patch new file mode 100644 index 0000000..bbd6f8d --- /dev/null +++ b/data/patches/0002-Bug-1013064-part-2-Store-sensitive-FxA-credentials-i.patch @@ -0,0 +1,551 @@ +From 4a92f9ee1ba35989f82a24bba18806f8616a5be8 Mon Sep 17 00:00:00 2001 +From: Mark Hammond <mhammond@skippinet.com.au> +Date: Sat, 14 Jun 2014 14:33:20 +1000 +Subject: Bug 1013064 (part 2) - Store sensitive FxA credentials in the login + manager. r=ckarlof,dveditz + +--- + services/fxaccounts/FxAccounts.jsm | 170 ++++++++++++++++++ + services/fxaccounts/FxAccountsCommon.js | 13 ++ + services/fxaccounts/moz.build | 5 +- + .../tests/xpcshell/test_loginmgr_storage.js | 196 +++++++++++++++++++++ + services/fxaccounts/tests/xpcshell/xpcshell.ini | 2 + + services/sync/modules/util.js | 12 +- + 6 files changed, 396 insertions(+), 2 deletions(-) + create mode 100644 services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js + +diff --git a/services/fxaccounts/FxAccounts.jsm b/services/fxaccounts/FxAccounts.jsm +index cc521b8..e9328dd 100644 +--- a/services/fxaccounts/FxAccounts.jsm ++++ b/services/fxaccounts/FxAccounts.jsm +@@ -298,17 +298,22 @@ function FxAccountsInternal() { + // able to abort all work on the first sign-in process. The currentTimer and + // currentAccountState are used for this purpose. + // (XXX - should the timer be directly on the currentAccountState?) + this.currentTimer = null; + this.currentAccountState = new AccountState(this); + + // We don't reference |profileDir| in the top-level module scope + // as we may be imported before we know where it is. ++ // We only want the fancy new LoginManagerStorage on desktop. ++#if defined(MOZ_B2G) + this.signedInUserStorage = new JSONStorage({ ++#else ++ this.signedInUserStorage = new LoginManagerStorage({ ++#endif + filename: DEFAULT_STORAGE_FILENAME, + baseDir: OS.Constants.Path.profileDir, + }); + } + + /** + * The internal API's prototype. + */ +@@ -896,16 +901,181 @@ JSONStorage.prototype = { + .then(CommonUtils.writeJSON.bind(null, contents, this.path)); + }, + + get: function() { + return CommonUtils.readJSON(this.path); + } + }; + ++/** ++ * LoginManagerStorage constructor that creates instances that may set/get ++ * from a combination of a clear-text JSON file and stored securely in ++ * the nsILoginManager. ++ * ++ * @param options { ++ * filename: of the plain-text file to write to ++ * baseDir: directory where the file resides ++ * } ++ * @return instance ++ */ ++ ++function LoginManagerStorage(options) { ++ // we reuse the JSONStorage for writing the plain-text stuff. ++ this.jsonStorage = new JSONStorage(options); ++} ++ ++LoginManagerStorage.prototype = { ++ // The fields in the credentials JSON object that are stored in plain-text ++ // in the profile directory. All other fields are stored in the login manager, ++ // and thus are only available when the master-password is unlocked. ++ ++ // a hook point for testing. ++ get _isLoggedIn() { ++ return Services.logins.isLoggedIn; ++ }, ++ ++ // Clear any data from the login manager. Returns true if the login manager ++ // was unlocked (even if no existing logins existed) or false if it was ++ // locked (meaning we don't even know if it existed or not.) ++ _clearLoginMgrData: Task.async(function* () { ++ try { // Services.logins might be third-party and broken... ++ yield Services.logins.initializationPromise; ++ if (!this._isLoggedIn) { ++ return false; ++ } ++ let logins = Services.logins.findLogins({}, FXA_PWDMGR_HOST, null, FXA_PWDMGR_REALM); ++ for (let login of logins) { ++ Services.logins.removeLogin(login); ++ } ++ return true; ++ } catch (ex) { ++ log.error("Failed to clear login data: ${}", ex); ++ return false; ++ } ++ }), ++ ++ set: Task.async(function* (contents) { ++ if (!contents) { ++ // User is signing out - write the null to the json file. ++ yield this.jsonStorage.set(contents); ++ ++ // And nuke it from the login manager. ++ let cleared = yield this._clearLoginMgrData(); ++ if (!cleared) { ++ // just log a message - we verify that the email address matches when ++ // we reload it, so having a stale entry doesn't really hurt. ++ log.info("not removing credentials from login manager - not logged in"); ++ } ++ return; ++ } ++ ++ // We are saving actual data. ++ // Split the data into 2 chunks - one to go to the plain-text, and the ++ // other to write to the login manager. ++ let toWriteJSON = {version: contents.version}; ++ let accountDataJSON = toWriteJSON.accountData = {}; ++ let toWriteLoginMgr = {version: contents.version}; ++ let accountDataLoginMgr = toWriteLoginMgr.accountData = {}; ++ for (let [name, value] of Iterator(contents.accountData)) { ++ if (FXA_PWDMGR_PLAINTEXT_FIELDS.indexOf(name) >= 0) { ++ accountDataJSON[name] = value; ++ } else { ++ accountDataLoginMgr[name] = value; ++ } ++ } ++ yield this.jsonStorage.set(toWriteJSON); ++ ++ try { // Services.logins might be third-party and broken... ++ // and the stuff into the login manager. ++ yield Services.logins.initializationPromise; ++ // If MP is locked we silently fail - the user may need to re-auth ++ // next startup. ++ if (!this._isLoggedIn) { ++ log.info("not saving credentials to login manager - not logged in"); ++ return; ++ } ++ // write the rest of the data to the login manager. ++ let loginInfo = new Components.Constructor( ++ "@mozilla.org/login-manager/loginInfo;1", Ci.nsILoginInfo, "init"); ++ let login = new loginInfo(FXA_PWDMGR_HOST, ++ null, // aFormSubmitURL, ++ FXA_PWDMGR_REALM, // aHttpRealm, ++ contents.accountData.email, // aUsername ++ JSON.stringify(toWriteLoginMgr), // aPassword ++ "", // aUsernameField ++ "");// aPasswordField ++ ++ let existingLogins = Services.logins.findLogins({}, FXA_PWDMGR_HOST, null, ++ FXA_PWDMGR_REALM); ++ if (existingLogins.length) { ++ Services.logins.modifyLogin(existingLogins[0], login); ++ } else { ++ Services.logins.addLogin(login); ++ } ++ } catch (ex) { ++ log.error("Failed to save data to the login manager: ${}", ex); ++ } ++ }), ++ ++ get: Task.async(function* () { ++ // we need to suck some data from the .json file in the profile dir and ++ // some other from the login manager. ++ let data = yield this.jsonStorage.get(); ++ if (!data) { ++ // no user logged in, nuke the storage data incase we couldn't remove ++ // it previously and then we are done. ++ yield this._clearLoginMgrData(); ++ return null; ++ } ++ ++ // if we have encryption keys it must have been saved before we ++ // used the login manager, so re-save it. ++ if (data.accountData.kA || data.accountData.kB || data.keyFetchToken) { ++ log.info("account data needs migration to the login manager."); ++ yield this.set(data); ++ } ++ ++ try { // Services.logins might be third-party and broken... ++ // read the data from the login manager and merge it for return. ++ yield Services.logins.initializationPromise; ++ ++ if (!this._isLoggedIn) { ++ log.info("returning partial account data as the login manager is locked."); ++ return data; ++ } ++ ++ let logins = Services.logins.findLogins({}, FXA_PWDMGR_HOST, null, FXA_PWDMGR_REALM); ++ if (logins.length == 0) { ++ // This could happen if the MP was locked when we wrote the data. ++ log.info("Can't find the rest of the credentials in the login manager"); ++ return data; ++ } ++ let login = logins[0]; ++ if (login.username == data.accountData.email) { ++ let lmData = JSON.parse(login.password); ++ if (lmData.version == data.version) { ++ // Merge the login manager data ++ copyObjectProperties(lmData.accountData, data.accountData); ++ } else { ++ log.info("version field in the login manager doesn't match - ignoring it"); ++ yield this._clearLoginMgrData(); ++ } ++ } else { ++ log.info("username in the login manager doesn't match - ignoring it"); ++ yield this._clearLoginMgrData(); ++ } ++ } catch (ex) { ++ log.error("Failed to get data from the login manager: ${}", ex); ++ } ++ return data; ++ }), ++ ++} ++ + // A getter for the instance to export + XPCOMUtils.defineLazyGetter(this, "fxAccounts", function() { + let a = new FxAccounts(); + + // XXX Bug 947061 - We need a strategy for resuming email verification after + // browser restart + a.loadAndPoll(); + +diff --git a/services/fxaccounts/FxAccountsCommon.js b/services/fxaccounts/FxAccountsCommon.js +index 2bef093..476e528 100644 +--- a/services/fxaccounts/FxAccountsCommon.js ++++ b/services/fxaccounts/FxAccountsCommon.js +@@ -170,10 +170,23 @@ SERVER_ERRNO_TO_ERROR[ERRNO_INVALID_AUTH_NONCE] = ERROR_INVALID_AUTH + SERVER_ERRNO_TO_ERROR[ERRNO_ENDPOINT_NO_LONGER_SUPPORTED] = ERROR_ENDPOINT_NO_LONGER_SUPPORTED; + SERVER_ERRNO_TO_ERROR[ERRNO_INCORRECT_LOGIN_METHOD] = ERROR_INCORRECT_LOGIN_METHOD; + SERVER_ERRNO_TO_ERROR[ERRNO_INCORRECT_KEY_RETRIEVAL_METHOD] = ERROR_INCORRECT_KEY_RETRIEVAL_METHOD; + SERVER_ERRNO_TO_ERROR[ERRNO_INCORRECT_API_VERSION] = ERROR_INCORRECT_API_VERSION; + SERVER_ERRNO_TO_ERROR[ERRNO_INCORRECT_EMAIL_CASE] = ERROR_INCORRECT_EMAIL_CASE; + SERVER_ERRNO_TO_ERROR[ERRNO_SERVICE_TEMP_UNAVAILABLE] = ERROR_SERVICE_TEMP_UNAVAILABLE; + SERVER_ERRNO_TO_ERROR[ERRNO_UNKNOWN_ERROR] = ERROR_UNKNOWN; + ++// FxAccounts has the ability to "split" the credentials between a plain-text ++// JSON file in the profile dir and in the login manager. ++// These constants relate to that. ++ ++// The fields we save in the plaintext JSON. ++// See bug 1013064 comments 23-25 for why the sessionToken is "safe" ++this.FXA_PWDMGR_PLAINTEXT_FIELDS = ["email", "verified", "authAt", ++ "sessionToken", "uid"]; ++// The pseudo-host we use in the login manager ++this.FXA_PWDMGR_HOST = "chrome://FirefoxAccounts"; ++// The realm we use in the login manager. ++this.FXA_PWDMGR_REALM = "Firefox Accounts credentials"; ++ + // Allow this file to be imported via Components.utils.import(). + this.EXPORTED_SYMBOLS = Object.keys(this); +diff --git a/services/fxaccounts/moz.build b/services/fxaccounts/moz.build +index f959714..1bb8c09 100644 +--- a/services/fxaccounts/moz.build ++++ b/services/fxaccounts/moz.build +@@ -5,16 +5,19 @@ + # file, You can obtain one at http://mozilla.org/MPL/2.0/. + + PARALLEL_DIRS += ['interfaces'] + + TEST_DIRS += ['tests'] + + EXTRA_JS_MODULES += [ + 'Credentials.jsm', +- 'FxAccounts.jsm', + 'FxAccountsClient.jsm', + 'FxAccountsCommon.js' + ] + ++EXTRA_PP_JS_MODULES += [ ++ 'FxAccounts.jsm', ++] ++ + # For now, we will only be using the FxA manager in B2G. + if CONFIG['MOZ_B2G']: + EXTRA_JS_MODULES += ['FxAccountsManager.jsm'] +diff --git a/services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js b/services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js +new file mode 100644 +index 0000000..297b256 +--- /dev/null ++++ b/services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js +@@ -0,0 +1,196 @@ ++/* Any copyright is dedicated to the Public Domain. ++ * http://creativecommons.org/publicdomain/zero/1.0/ */ ++ ++"use strict"; ++ ++// Tests for FxAccounts, storage and the master password. ++ ++// Stop us hitting the real auth server. ++Services.prefs.setCharPref("identity.fxaccounts.auth.uri", "http://localhost"); ++ ++Cu.import("resource://gre/modules/Services.jsm"); ++Cu.import("resource://gre/modules/FxAccounts.jsm"); ++Cu.import("resource://gre/modules/FxAccountsClient.jsm"); ++Cu.import("resource://gre/modules/FxAccountsCommon.js"); ++Cu.import("resource://gre/modules/osfile.jsm"); ++Cu.import("resource://services-common/utils.js"); ++Cu.import("resource://gre/modules/FxAccountsCommon.js"); ++ ++initTestLogging("Trace"); ++// See verbose logging from FxAccounts.jsm ++Services.prefs.setCharPref("identity.fxaccounts.loglevel", "DEBUG"); ++ ++function run_test() { ++ run_next_test(); ++} ++ ++function getLoginMgrData() { ++ let logins = Services.logins.findLogins({}, FXA_PWDMGR_HOST, null, FXA_PWDMGR_REALM); ++ if (logins.length == 0) { ++ return null; ++ } ++ Assert.equal(logins.length, 1, "only 1 login available"); ++ return logins[0]; ++} ++ ++add_task(function test_simple() { ++ let fxa = new FxAccounts({}); ++ ++ let creds = { ++ email: "test@example.com", ++ sessionToken: "sessionToken", ++ kA: "the kA value", ++ kB: "the kB value", ++ verified: true ++ }; ++ yield fxa.setSignedInUser(creds); ++ ++ // This should have stored stuff in both the .json file in the profile ++ // dir, and the login dir. ++ let path = OS.Path.join(OS.Constants.Path.profileDir, "signedInUser.json"); ++ let data = yield CommonUtils.readJSON(path); ++ ++ Assert.strictEqual(data.accountData.email, creds.email, "correct email in the clear text"); ++ Assert.strictEqual(data.accountData.sessionToken, creds.sessionToken, "correct sessionToken in the clear text"); ++ Assert.strictEqual(data.accountData.verified, creds.verified, "correct verified flag"); ++ ++ Assert.ok(!("kA" in data.accountData), "kA not stored in clear text"); ++ Assert.ok(!("kB" in data.accountData), "kB not stored in clear text"); ++ ++ let login = getLoginMgrData(); ++ Assert.strictEqual(login.username, creds.email, "email matches"); ++ let loginData = JSON.parse(login.password); ++ Assert.strictEqual(loginData.version, data.version, "same version flag in both places"); ++ Assert.strictEqual(loginData.accountData.kA, creds.kA, "correct kA in the login mgr"); ++ Assert.strictEqual(loginData.accountData.kB, creds.kB, "correct kB in the login mgr"); ++ ++ Assert.ok(!("email" in loginData), "email not stored in the login mgr json"); ++ Assert.ok(!("sessionToken" in loginData), "sessionToken not stored in the login mgr json"); ++ Assert.ok(!("verified" in loginData), "verified not stored in the login mgr json"); ++ ++ yield fxa.signOut(/* localOnly = */ true); ++ Assert.strictEqual(getLoginMgrData(), null, "login mgr data deleted on logout"); ++}); ++ ++add_task(function test_MPLocked() { ++ let fxa = new FxAccounts({}); ++ ++ let creds = { ++ email: "test@example.com", ++ sessionToken: "sessionToken", ++ kA: "the kA value", ++ kB: "the kB value", ++ verified: true ++ }; ++ ++ // tell the storage that the MP is locked. ++ fxa.internal.signedInUserStorage.__defineGetter__("_isLoggedIn", function() false); ++ yield fxa.setSignedInUser(creds); ++ ++ // This should have stored stuff in the .json, and the login manager stuff ++ // will not exist. ++ let path = OS.Path.join(OS.Constants.Path.profileDir, "signedInUser.json"); ++ let data = yield CommonUtils.readJSON(path); ++ ++ Assert.strictEqual(data.accountData.email, creds.email, "correct email in the clear text"); ++ Assert.strictEqual(data.accountData.sessionToken, creds.sessionToken, "correct sessionToken in the clear text"); ++ Assert.strictEqual(data.accountData.verified, creds.verified, "correct verified flag"); ++ ++ Assert.ok(!("kA" in data.accountData), "kA not stored in clear text"); ++ Assert.ok(!("kB" in data.accountData), "kB not stored in clear text"); ++ ++ Assert.strictEqual(getLoginMgrData(), null, "login mgr data doesn't exist"); ++ yield fxa.signOut(/* localOnly = */ true) ++}); ++ ++add_task(function test_consistentWithMPEdgeCases() { ++ let fxa = new FxAccounts({}); ++ ++ let creds1 = { ++ email: "test@example.com", ++ sessionToken: "sessionToken", ++ kA: "the kA value", ++ kB: "the kB value", ++ verified: true ++ }; ++ ++ let creds2 = { ++ email: "test2@example.com", ++ sessionToken: "sessionToken2", ++ kA: "the kA value2", ++ kB: "the kB value2", ++ verified: false, ++ }; ++ ++ // Log a user in while MP is unlocked. ++ yield fxa.setSignedInUser(creds1); ++ ++ // tell the storage that the MP is locked - this will prevent logout from ++ // being able to clear the data. ++ fxa.internal.signedInUserStorage.__defineGetter__("_isLoggedIn", function() false); ++ ++ // now set the second credentials. ++ yield fxa.setSignedInUser(creds2); ++ ++ // We should still have creds1 data in the login manager. ++ let login = getLoginMgrData(); ++ Assert.strictEqual(login.username, creds1.email); ++ // and that we do have the first kA in the login manager. ++ Assert.strictEqual(JSON.parse(login.password).accountData.kA, creds1.kA, ++ "stale data still in login mgr"); ++ ++ // Make a new FxA instance (otherwise the values in memory will be used.) ++ // Because we haven't overridden _isLoggedIn for this new instance it will ++ // treat the MP as unlocked. ++ let fxa = new FxAccounts({}); ++ ++ let accountData = yield fxa.getSignedInUser(); ++ Assert.strictEqual(accountData.email, creds2.email); ++ // we should have no kA at all. ++ Assert.strictEqual(accountData.kA, undefined, "stale kA wasn't used"); ++ yield fxa.signOut(/* localOnly = */ true) ++}); ++ ++add_task(function test_migration() { ++ // manually write out the full creds data to the JSON - this will look like ++ // old data that needs migration. ++ let creds = { ++ email: "test@example.com", ++ sessionToken: "sessionToken", ++ kA: "the kA value", ++ kB: "the kB value", ++ verified: true ++ }; ++ let toWrite = { ++ version: 1, ++ accountData: creds, ++ }; ++ ++ let path = OS.Path.join(OS.Constants.Path.profileDir, "signedInUser.json"); ++ let data = yield CommonUtils.writeJSON(toWrite, path); ++ ++ // Create an FxA object - and tell it to load the data. ++ let fxa = new FxAccounts({}); ++ data = yield fxa.getSignedInUser(); ++ ++ Assert.deepEqual(data, creds, "we should have everything available"); ++ ++ // now sniff the data on disk - it should have been magically migrated. ++ data = yield CommonUtils.readJSON(path); ++ ++ Assert.strictEqual(data.accountData.email, creds.email, "correct email in the clear text"); ++ Assert.strictEqual(data.accountData.sessionToken, creds.sessionToken, "correct sessionToken in the clear text"); ++ Assert.strictEqual(data.accountData.verified, creds.verified, "correct verified flag"); ++ ++ Assert.ok(!("kA" in data.accountData), "kA not stored in clear text"); ++ Assert.ok(!("kB" in data.accountData), "kB not stored in clear text"); ++ ++ // and it should magically be in the login manager. ++ let login = getLoginMgrData(); ++ Assert.strictEqual(login.username, creds.email); ++ // and that we do have the first kA in the login manager. ++ Assert.strictEqual(JSON.parse(login.password).accountData.kA, creds.kA, ++ "kA was migrated"); ++ ++ yield fxa.signOut(/* localOnly = */ true) ++}); +diff --git a/services/fxaccounts/tests/xpcshell/xpcshell.ini b/services/fxaccounts/tests/xpcshell/xpcshell.ini +index 9d9bffe..4448d76 100644 +--- a/services/fxaccounts/tests/xpcshell/xpcshell.ini ++++ b/services/fxaccounts/tests/xpcshell/xpcshell.ini +@@ -1,10 +1,12 @@ + [DEFAULT] + head = head.js ../../../common/tests/unit/head_helpers.js ../../../common/tests/unit/head_http.js + tail = + + [test_accounts.js] + [test_client.js] + [test_credentials.js] ++[test_loginmgr_storage.js] ++skip-if = appname == 'b2g' # login manager storage only used on desktop. + [test_manager.js] + run-if = appname == 'b2g' + reason = FxAccountsManager is only available for B2G for now +diff --git a/services/sync/modules/util.js b/services/sync/modules/util.js +index 194e0b2..4691428 100644 +--- a/services/sync/modules/util.js ++++ b/services/sync/modules/util.js +@@ -14,16 +14,23 @@ Cu.import("resource://services-common/async.js", this); + Cu.import("resource://services-crypto/utils.js"); + Cu.import("resource://services-sync/constants.js"); + Cu.import("resource://gre/modules/Preferences.jsm"); + Cu.import("resource://gre/modules/Services.jsm", this); + Cu.import("resource://gre/modules/XPCOMUtils.jsm", this); + Cu.import("resource://gre/modules/osfile.jsm", this); + Cu.import("resource://gre/modules/Task.jsm", this); + ++// FxAccountsCommon.js doesn't use a "namespace", so create one here. ++XPCOMUtils.defineLazyGetter(this, "FxAccountsCommon", function() { ++ let FxAccountsCommon = {}; ++ Cu.import("resource://gre/modules/FxAccountsCommon.js", FxAccountsCommon); ++ return FxAccountsCommon; ++}); ++ + /* + * Utility functions + */ + + this.Utils = { + // Alias in functions from CommonUtils. These previously were defined here. + // In the ideal world, references to these would be removed. + nextTick: CommonUtils.nextTick, +@@ -589,18 +596,21 @@ this.Utils = { + * reset when we drop sync credentials, etc. + */ + getSyncCredentialsHosts: function() { + // This is somewhat expensive and the result static, so we cache the result. + if (this._syncCredentialsHosts) { + return this._syncCredentialsHosts; + } + let result = new Set(); +- // the legacy sync host. ++ // the legacy sync host + result.add(PWDMGR_HOST); ++ // the FxA host ++ result.add(FxAccountsCommon.FXA_PWDMGR_HOST); ++ // + // The FxA hosts - these almost certainly all have the same hostname, but + // better safe than sorry... + for (let prefName of ["identity.fxaccounts.remote.force_auth.uri", + "identity.fxaccounts.remote.signup.uri", + "identity.fxaccounts.remote.signin.uri", + "identity.fxaccounts.settings.uri"]) { + let prefVal; + try { +-- +1.8.3.msysgit.0 + diff --git a/data/patches/0003-Bug-1013064-part-3-only-migrate-data-into-the-loginm.patch b/data/patches/0003-Bug-1013064-part-3-only-migrate-data-into-the-loginm.patch new file mode 100644 index 0000000..063a031 --- /dev/null +++ b/data/patches/0003-Bug-1013064-part-3-only-migrate-data-into-the-loginm.patch @@ -0,0 +1,194 @@ +From 86c67f9b9081ce905442c86b38575b3422c8dce3 Mon Sep 17 00:00:00 2001 +From: Mark Hammond <mhammond@skippinet.com.au> +Date: Wed, 18 Jun 2014 15:07:41 +1000 +Subject: Bug 1013064 (part 3) - only migrate data into the loginmgr when it is + unlocked. r=ckarlof + +--- + services/fxaccounts/FxAccounts.jsm | 25 ++++- + .../tests/xpcshell/test_loginmgr_storage.js | 113 +++++++++++++++++++++ + 2 files changed, 137 insertions(+), 1 deletion(-) + +diff --git a/services/fxaccounts/FxAccounts.jsm b/services/fxaccounts/FxAccounts.jsm +index e9328dd..14d71fc 100644 +--- a/services/fxaccounts/FxAccounts.jsm ++++ b/services/fxaccounts/FxAccounts.jsm +@@ -1025,17 +1025,40 @@ LoginManagerStorage.prototype = { + // it previously and then we are done. + yield this._clearLoginMgrData(); + return null; + } + + // if we have encryption keys it must have been saved before we + // used the login manager, so re-save it. + if (data.accountData.kA || data.accountData.kB || data.keyFetchToken) { +- log.info("account data needs migration to the login manager."); ++ // We need to migrate, but the MP might be locked (eg, on the first run ++ // with this enabled, we will get here very soon after startup, so will ++ // certainly be locked.) This means we can't actually store the data in ++ // the login manager (and thus might lose it if we migrated now) ++ // So if the MP is locked, we *don't* migrate, but still just return ++ // the subset of data we now store in the JSON. ++ // This will cause sync to notice the lack of keys, force an unlock then ++ // re-fetch the account data to see if the keys are there. At *that* ++ // point we will end up back here, but because the MP is now unlocked ++ // we can actually perform the migration. ++ if (!this._isLoggedIn) { ++ // return the "safe" subset but leave the storage alone. ++ log.info("account data needs migration to the login manager but the MP is locked."); ++ let result = { ++ version: data.version, ++ accountData: {}, ++ }; ++ for (let fieldName of FXA_PWDMGR_PLAINTEXT_FIELDS) { ++ result.accountData[fieldName] = data.accountData[fieldName]; ++ } ++ return result; ++ } ++ // actually migrate - just calling .set() will split everything up. ++ log.info("account data is being migrated to the login manager."); + yield this.set(data); + } + + try { // Services.logins might be third-party and broken... + // read the data from the login manager and merge it for return. + yield Services.logins.initializationPromise; + + if (!this._isLoggedIn) { +diff --git a/services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js b/services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js +index 297b256..a9cf5f4 100644 +--- a/services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js ++++ b/services/fxaccounts/tests/xpcshell/test_loginmgr_storage.js +@@ -98,16 +98,129 @@ add_task(function test_MPLocked() { + + Assert.ok(!("kA" in data.accountData), "kA not stored in clear text"); + Assert.ok(!("kB" in data.accountData), "kB not stored in clear text"); + + Assert.strictEqual(getLoginMgrData(), null, "login mgr data doesn't exist"); + yield fxa.signOut(/* localOnly = */ true) + }); + ++add_task(function test_migrationMPUnlocked() { ++ // first manually save a signedInUser.json to simulate a first-run with ++ // pre-migrated data. ++ let fxa = new FxAccounts({}); ++ ++ let creds = { ++ email: "test@example.com", ++ sessionToken: "sessionToken", ++ kA: "the kA value", ++ kB: "the kB value", ++ verified: true ++ }; ++ let toWrite = { ++ version: fxa.version, ++ accountData: creds, ++ } ++ ++ let path = OS.Path.join(OS.Constants.Path.profileDir, "signedInUser.json"); ++ yield CommonUtils.writeJSON(toWrite, path); ++ ++ // now load it - it should migrate. ++ let data = yield fxa.getSignedInUser(); ++ Assert.deepEqual(data, creds, "we got all the data back"); ++ ++ // and verify it was actually migrated - re-read signedInUser back. ++ let data = yield CommonUtils.readJSON(path); ++ ++ Assert.strictEqual(data.accountData.email, creds.email, "correct email in the clear text"); ++ Assert.strictEqual(data.accountData.sessionToken, creds.sessionToken, "correct sessionToken in the clear text"); ++ Assert.strictEqual(data.accountData.verified, creds.verified, "correct verified flag"); ++ ++ Assert.ok(!("kA" in data.accountData), "kA not stored in clear text"); ++ Assert.ok(!("kB" in data.accountData), "kB not stored in clear text"); ++ ++ let login = getLoginMgrData(); ++ Assert.strictEqual(login.username, creds.email, "email matches"); ++ let loginData = JSON.parse(login.password); ++ Assert.strictEqual(loginData.version, data.version, "same version flag in both places"); ++ Assert.strictEqual(loginData.accountData.kA, creds.kA, "correct kA in the login mgr"); ++ Assert.strictEqual(loginData.accountData.kB, creds.kB, "correct kB in the login mgr"); ++ ++ Assert.ok(!("email" in loginData), "email not stored in the login mgr json"); ++ Assert.ok(!("sessionToken" in loginData), "sessionToken not stored in the login mgr json"); ++ Assert.ok(!("verified" in loginData), "verified not stored in the login mgr json"); ++ ++ yield fxa.signOut(/* localOnly = */ true); ++ Assert.strictEqual(getLoginMgrData(), null, "login mgr data deleted on logout"); ++}); ++ ++add_task(function test_migrationMPLocked() { ++ // first manually save a signedInUser.json to simulate a first-run with ++ // pre-migrated data. ++ let fxa = new FxAccounts({}); ++ ++ let creds = { ++ email: "test@example.com", ++ sessionToken: "sessionToken", ++ kA: "the kA value", ++ kB: "the kB value", ++ verified: true ++ }; ++ let toWrite = { ++ version: fxa.version, ++ accountData: creds, ++ } ++ ++ let path = OS.Path.join(OS.Constants.Path.profileDir, "signedInUser.json"); ++ yield CommonUtils.writeJSON(toWrite, path); ++ ++ // pretend the MP is locked. ++ fxa.internal.signedInUserStorage.__defineGetter__("_isLoggedIn", function() false); ++ ++ // now load it - it should *not* migrate, but should only give the JSON-safe ++ // data back. ++ let data = yield fxa.getSignedInUser(); ++ Assert.ok(!data.kA); ++ Assert.ok(!data.kB); ++ ++ // and verify the data on disk wan't migrated. ++ data = yield CommonUtils.readJSON(path); ++ Assert.deepEqual(data, toWrite); ++ ++ // Now "unlock" and re-ask for the signedInUser - it should migrate. ++ fxa.internal.signedInUserStorage.__defineGetter__("_isLoggedIn", function() true); ++ data = yield fxa.getSignedInUser(); ++ // this time we should have got all the data, not just the JSON-safe fields. ++ Assert.strictEqual(data.kA, creds.kA); ++ Assert.strictEqual(data.kB, creds.kB); ++ ++ // And verify the data in the JSON was migrated ++ data = yield CommonUtils.readJSON(path); ++ Assert.strictEqual(data.accountData.email, creds.email, "correct email in the clear text"); ++ Assert.strictEqual(data.accountData.sessionToken, creds.sessionToken, "correct sessionToken in the clear text"); ++ Assert.strictEqual(data.accountData.verified, creds.verified, "correct verified flag"); ++ ++ Assert.ok(!("kA" in data.accountData), "kA not stored in clear text"); ++ Assert.ok(!("kB" in data.accountData), "kB not stored in clear text"); ++ ++ let login = getLoginMgrData(); ++ Assert.strictEqual(login.username, creds.email, "email matches"); ++ let loginData = JSON.parse(login.password); ++ Assert.strictEqual(loginData.version, data.version, "same version flag in both places"); ++ Assert.strictEqual(loginData.accountData.kA, creds.kA, "correct kA in the login mgr"); ++ Assert.strictEqual(loginData.accountData.kB, creds.kB, "correct kB in the login mgr"); ++ ++ Assert.ok(!("email" in loginData), "email not stored in the login mgr json"); ++ Assert.ok(!("sessionToken" in loginData), "sessionToken not stored in the login mgr json"); ++ Assert.ok(!("verified" in loginData), "verified not stored in the login mgr json"); ++ ++ yield fxa.signOut(/* localOnly = */ true); ++ Assert.strictEqual(getLoginMgrData(), null, "login mgr data deleted on logout"); ++}); ++ + add_task(function test_consistentWithMPEdgeCases() { + let fxa = new FxAccounts({}); + + let creds1 = { + email: "test@example.com", + sessionToken: "sessionToken", + kA: "the kA value", + kB: "the kB value", +-- +1.8.3.msysgit.0 + diff --git a/data/patches/0004-Bug-1013064-part-4b-browserid_identity-and-sync-chang.patch b/data/patches/0004-Bug-1013064-part-4b-browserid_identity-and-sync-chang.patch new file mode 100644 index 0000000..369bde6 --- /dev/null +++ b/data/patches/0004-Bug-1013064-part-4b-browserid_identity-and-sync-chang.patch @@ -0,0 +1,286 @@ +From 9717484083e66b78eedfa14e539d51382aba760f Mon Sep 17 00:00:00 2001 +From: Mark Hammond <mhammond@skippinet.com.au> +Date: Sat, 14 Jun 2014 14:33:56 +1000 +Subject: Bug 1013064 (part 4) - browserid_identity and sync changes to support + FxA credentials in the login manager. r=ckarlof,rnewman + +--- + services/sync/modules/browserid_identity.js | 61 ++++++++++++++++++++-- + services/sync/modules/identity.js | 19 +++++++ + services/sync/modules/service.js | 20 ++++--- + .../sync/tests/unit/test_browserid_identity.js | 15 ++++++ + 4 files changed, 102 insertions(+), 13 deletions(-) + +diff --git a/services/sync/modules/browserid_identity.js b/services/sync/modules/browserid_identity.js +--- a/services/sync/modules/browserid_identity.js ++++ b/services/sync/modules/browserid_identity.js +@@ -394,41 +394,83 @@ this.BrowserIDManager.prototype = { + this._syncKeyUpdated = true; + this._shouldHaveSyncKeyBundle = false; + }, + + /** + * The current state of the auth credentials. + * + * This essentially validates that enough credentials are available to use +- * Sync. ++ * Sync, although it effectively ignores the state of the master-password - ++ * if that's locked and that's the only problem we can see, say everything ++ * is OK - unlockAndVerifyAuthState will be used to perform the unlock ++ * and re-verification if necessary. + */ + get currentAuthState() { + if (this._authFailureReason) { + this._log.info("currentAuthState returning " + this._authFailureReason + + " due to previous failure"); + return this._authFailureReason; + } + // TODO: need to revisit this. Currently this isn't ready to go until + // both the username and syncKeyBundle are both configured and having no + // username seems to make things fail fast so that's good. + if (!this.username) { + return LOGIN_FAILED_NO_USERNAME; + } + + // No need to check this.syncKey as our getter for that attribute + // uses this.syncKeyBundle +- // If bundle creation started, but failed. +- if (this._shouldHaveSyncKeyBundle && !this.syncKeyBundle) { +- return LOGIN_FAILED_NO_PASSPHRASE; ++ // If bundle creation started, but failed due to any reason other than ++ // the MP being locked... ++ if (this._shouldHaveSyncKeyBundle && !this.syncKeyBundle && !Utils.mpLocked()) { ++ // Return a state that says a re-auth is necessary so we can get keys. ++ return LOGIN_FAILED_LOGIN_REJECTED; + } + + return STATUS_OK; + }, + ++ // Do we currently have keys, or do we have enough that we should be able ++ // to successfully fetch them? ++ _canFetchKeys: function() { ++ let userData = this._signedInUser; ++ // a keyFetchToken means we can almost certainly grab them. ++ // kA and kB means we already have them. ++ return userData && (userData.keyFetchToken || (userData.kA && userData.kB)); ++ }, ++ ++ /** ++ * Verify the current auth state, unlocking the master-password if necessary. ++ * ++ * Returns a promise that resolves with the current auth state after ++ * attempting to unlock. ++ */ ++ unlockAndVerifyAuthState: function() { ++ if (this._canFetchKeys()) { ++ return Promise.resolve(STATUS_OK); ++ } ++ // so no keys - ensure MP unlocked. ++ if (!Utils.ensureMPUnlocked()) { ++ // user declined to unlock, so we don't know if they are stored there. ++ return Promise.resolve(MASTER_PASSWORD_LOCKED); ++ } ++ // now we are unlocked we must re-fetch the user data as we may now have ++ // the details that were previously locked away. ++ return this._fxaService.getSignedInUser().then( ++ accountData => { ++ this._updateSignedInUser(accountData); ++ // If we still can't get keys it probably means the user authenticated ++ // without unlocking the MP or cleared the saved logins, so we've now ++ // lost them - the user will need to reauth before continuing. ++ return this._canFetchKeys() ? STATUS_OK : LOGIN_FAILED_LOGIN_REJECTED; ++ } ++ ); ++ }, ++ + /** + * Do we have a non-null, not yet expired token for the user currently + * signed in? + */ + hasValidToken: function() { + if (!this._token) { + return false; + } +@@ -444,16 +486,24 @@ this.BrowserIDManager.prototype = { + if (tokenServerURI.endsWith("/")) { // trailing slashes cause problems... + tokenServerURI = tokenServerURI.slice(0, -1); + } + let log = this._log; + let client = this._tokenServerClient; + let fxa = this._fxaService; + let userData = this._signedInUser; + ++ // We need kA and kB for things to work. If we don't have them, just ++ // return null for the token - sync calling unlockAndVerifyAuthState() ++ // before actually syncing will setup the error states if necessary. ++ if (!this._canFetchKeys()) { ++ log.info("_fetchTokenForUser has no keys to use."); ++ return null; ++ } ++ + log.info("Fetching assertion and token from: " + tokenServerURI); + + let maybeFetchKeys = () => { + // This is called at login time and every time we need a new token - in + // the latter case we already have kA and kB, so optimise that case. + if (userData.kA && userData.kB) { + return; + } +@@ -519,17 +569,18 @@ this.BrowserIDManager.prototype = { + // TODO: write tests to make sure that different auth error cases are handled here + // properly: auth error getting assertion, auth error getting token (invalid generation + // and client-state error) + if (err instanceof AuthenticationError) { + this._log.error("Authentication error in _fetchTokenForUser: " + err); + // set it to the "fatal" LOGIN_FAILED_LOGIN_REJECTED reason. + this._authFailureReason = LOGIN_FAILED_LOGIN_REJECTED; + } else { +- this._log.error("Non-authentication error in _fetchTokenForUser: " + err.message); ++ this._log.error("Non-authentication error in _fetchTokenForUser: " ++ + (err.message || err)); + // for now assume it is just a transient network related problem. + this._authFailureReason = LOGIN_FAILED_NETWORK_ERROR; + } + // Drop the sync key bundle, but still expect to have one. + // This will arrange for us to be in the right 'currentAuthState' + // such that UI will show the right error. + this._shouldHaveSyncKeyBundle = true; + Weave.Status.login = this._authFailureReason; +diff --git a/services/sync/modules/identity.js b/services/sync/modules/identity.js +--- a/services/sync/modules/identity.js ++++ b/services/sync/modules/identity.js +@@ -373,16 +373,35 @@ IdentityManager.prototype = { + if (!this.syncKeyBundle) { + return LOGIN_FAILED_INVALID_PASSPHRASE; + } + + return STATUS_OK; + }, + + /** ++ * Verify the current auth state, unlocking the master-password if necessary. ++ * ++ * Returns a promise that resolves with the current auth state after ++ * attempting to unlock. ++ */ ++ unlockAndVerifyAuthState: function() { ++ // Try to fetch the passphrase - this will prompt for MP unlock as a ++ // side-effect... ++ try { ++ this.syncKey; ++ } catch (ex) { ++ this._log.debug("Fetching passphrase threw " + ex + ++ "; assuming master password locked."); ++ return Promise.resolve(MASTER_PASSWORD_LOCKED); ++ } ++ return Promise.resolve(STATUS_OK); ++ }, ++ ++ /** + * Persist credentials to password store. + * + * When credentials are updated, they are changed in memory only. This will + * need to be called to save them to the underlying password store. + * + * If the password store is locked (e.g. if the master password hasn't been + * entered), this could throw an exception. + */ +diff --git a/services/sync/modules/service.js b/services/sync/modules/service.js +--- a/services/sync/modules/service.js ++++ b/services/sync/modules/service.js +@@ -679,27 +679,31 @@ Sync11Service.prototype = { + } + + if (!this.identity.username) { + this._log.warn("No username in verifyLogin."); + this.status.login = LOGIN_FAILED_NO_USERNAME; + return false; + } + +- // Unlock master password, or return. + // Attaching auth credentials to a request requires access to + // passwords, which means that Resource.get can throw MP-related + // exceptions! +- // Try to fetch the passphrase first, while we still have control. +- try { +- this.identity.syncKey; +- } catch (ex) { +- this._log.debug("Fetching passphrase threw " + ex + +- "; assuming master password locked."); +- this.status.login = MASTER_PASSWORD_LOCKED; ++ // So we ask the identity to verify the login state after unlocking the ++ // master password (ie, this call is expected to prompt for MP unlock ++ // if necessary) while we still have control. ++ let cb = Async.makeSpinningCallback(); ++ this.identity.unlockAndVerifyAuthState().then( ++ result => cb(null, result), ++ cb ++ ); ++ let unlockedState = cb.wait(); ++ this._log.debug("Fetching unlocked auth state returned " + unlockedState); ++ if (unlockedState != STATUS_OK) { ++ this.status.login = unlockedState; + return false; + } + + try { + // Make sure we have a cluster to verify against. + // This is a little weird, if we don't get a node we pretend + // to succeed, since that probably means we just don't have storage. + if (this.clusterURL == "" && !this._clusterManager.setCluster()) { +diff --git a/services/sync/tests/unit/test_browserid_identity.js b/services/sync/tests/unit/test_browserid_identity.js +--- a/services/sync/tests/unit/test_browserid_identity.js ++++ b/services/sync/tests/unit/test_browserid_identity.js +@@ -78,19 +78,33 @@ add_task(function test_initialializeWith + browseridManager.initializeWithCurrentIdentity(); + yield browseridManager.whenReadyToAuthenticate.promise; + do_check_true(!!browseridManager._token); + do_check_true(browseridManager.hasValidToken()); + do_check_eq(browseridManager.account, identityConfig.fxaccount.user.email); + } + ); + ++add_task(function test_initialializeWithNoKeys() { ++ _("Verify start after initializeWithCurrentIdentity without kA, kB or keyFetchToken"); ++ let identityConfig = makeIdentityConfig(); ++ delete identityConfig.fxaccount.user.kA; ++ delete identityConfig.fxaccount.user.kB; ++ // there's no keyFetchToken by default, so the initialize should fail. ++ configureFxAccountIdentity(browseridManager, identityConfig); ++ ++ yield browseridManager.initializeWithCurrentIdentity(); ++ yield browseridManager.whenReadyToAuthenticate.promise; ++ do_check_eq(Status.login, LOGIN_SUCCEEDED, "login succeeded even without keys"); ++ do_check_false(browseridManager._canFetchKeys(), "_canFetchKeys reflects lack of keys"); ++}); + + add_test(function test_getResourceAuthenticator() { + _("BrowserIDManager supplies a Resource Authenticator callback which returns a Hawk header."); ++ configureFxAccountIdentity(browseridManager); + let authenticator = browseridManager.getResourceAuthenticator(); + do_check_true(!!authenticator); + let req = {uri: CommonUtils.makeURI( + "https://example.net/somewhere/over/the/rainbow"), + method: 'GET'}; + let output = authenticator(req, 'GET'); + do_check_true('headers' in output); + do_check_true('authorization' in output.headers); +@@ -235,16 +249,17 @@ add_test(function test_RESTResourceAuthe + (getTimestampDelta(authHeader, now) - 12 * HOUR_MS) < 2 * MINUTE_MS); + + run_next_test(); + }); + + add_task(function test_ensureLoggedIn() { + configureFxAccountIdentity(browseridManager); + yield browseridManager.initializeWithCurrentIdentity(); ++ yield browseridManager.whenReadyToAuthenticate.promise; + Assert.equal(Status.login, LOGIN_SUCCEEDED, "original initialize worked"); + yield browseridManager.ensureLoggedIn(); + Assert.equal(Status.login, LOGIN_SUCCEEDED, "original ensureLoggedIn worked"); + Assert.ok(browseridManager._shouldHaveSyncKeyBundle, + "_shouldHaveSyncKeyBundle should always be true after ensureLogin completes."); + + // arrange for no logged in user. + let fxa = browseridManager._fxaService diff --git a/data/patches/0005-Bug-1013064-part-5-stop-disabling-the-password-engin.patch b/data/patches/0005-Bug-1013064-part-5-stop-disabling-the-password-engin.patch new file mode 100644 index 0000000..394d27c --- /dev/null +++ b/data/patches/0005-Bug-1013064-part-5-stop-disabling-the-password-engin.patch @@ -0,0 +1,519 @@ +From 07aa9cc1fcd5479976effe29f6adf5ad5ba7a8f8 Mon Sep 17 00:00:00 2001 +From: Mark Hammond <mhammond@skippinet.com.au> +Date: Thu, 12 Jun 2014 18:19:49 +1000 +Subject: Bug 1013064 (part 5) - stop disabling the password engine when MP + enabled. r=ttaubert + +diff --git a/browser/base/content/sync/customize.js b/browser/base/content/sync/customize.js +--- a/browser/base/content/sync/customize.js ++++ b/browser/base/content/sync/customize.js +@@ -1,25 +1,11 @@ + /* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + "use strict"; + +-const {classes: Cc, interfaces: Ci, utils: Cu} = Components; +- +-Cu.import("resource://gre/modules/Services.jsm"); +- +-let service = Cc["@mozilla.org/weave/service;1"] +- .getService(Ci.nsISupports) +- .wrappedJSObject; +- +-if (!service.allowPasswordsEngine) { +- let checkbox = document.getElementById("fxa-pweng-chk"); +- checkbox.checked = false; +- checkbox.disabled = true; +-} +- + addEventListener("dialogaccept", function () { + let pane = document.getElementById("sync-customize-pane"); + pane.writePreferences(true); + window.arguments[0].accepted = true; + }); +diff --git a/browser/base/content/sync/customize.xul b/browser/base/content/sync/customize.xul +--- a/browser/base/content/sync/customize.xul ++++ b/browser/base/content/sync/customize.xul +@@ -40,18 +40,17 @@ + + <vbox align="start"> + <checkbox label="&engine.tabs.label;" + accesskey="&engine.tabs.accesskey;" + preference="engine.tabs"/> + <checkbox label="&engine.bookmarks.label;" + accesskey="&engine.bookmarks.accesskey;" + preference="engine.bookmarks"/> +- <checkbox id="fxa-pweng-chk" +- label="&engine.passwords.label;" ++ <checkbox label="&engine.passwords.label;" + accesskey="&engine.passwords.accesskey;" + preference="engine.passwords"/> + <checkbox label="&engine.history.label;" + accesskey="&engine.history.accesskey;" + preference="engine.history"/> + <checkbox label="&engine.addons.label;" + accesskey="&engine.addons.accesskey;" + preference="engine.addons"/> +diff --git a/browser/base/content/sync/utils.js b/browser/base/content/sync/utils.js +--- a/browser/base/content/sync/utils.js ++++ b/browser/base/content/sync/utils.js +@@ -82,22 +82,16 @@ let gSyncUtils = { + this._openLink(Weave.Svc.Prefs.get(root + "termsURL")); + }, + + openPrivacyPolicy: function () { + let root = this.fxAccountsEnabled ? "fxa." : ""; + this._openLink(Weave.Svc.Prefs.get(root + "privacyURL")); + }, + +- openMPInfoPage: function (event) { +- event.stopPropagation(); +- let baseURL = Services.urlFormatter.formatURLPref("app.support.baseURL"); +- this._openLink(baseURL + "sync-master-password"); +- }, +- + openFirstSyncProgressPage: function () { + this._openLink("about:sync-progress"); + }, + + /** + * Prepare an invisible iframe with the passphrase backup document. + * Used by both the print and saving methods. + * +diff --git a/browser/components/preferences/in-content/sync.js b/browser/components/preferences/in-content/sync.js +--- a/browser/components/preferences/in-content/sync.js ++++ b/browser/components/preferences/in-content/sync.js +@@ -149,27 +149,16 @@ let gSyncPane = { + document.getElementById("fxaEmailAddress1").textContent = data.email; + document.getElementById("fxaEmailAddress2").textContent = data.email; + document.getElementById("fxaEmailAddress3").textContent = data.email; + document.getElementById("fxaSyncComputerName").value = Weave.Service.clientsEngine.localName; + let engines = document.getElementById("fxaSyncEngines") + for (let checkbox of engines.querySelectorAll("checkbox")) { + checkbox.disabled = enginesListDisabled; + } +- +- let checkbox = document.getElementById("fxa-pweng-chk"); +- let help = document.getElementById("fxa-pweng-help"); +- let allowPasswordsEngine = service.allowPasswordsEngine; +- +- if (!allowPasswordsEngine) { +- checkbox.checked = false; +- } +- +- checkbox.disabled = !allowPasswordsEngine || enginesListDisabled; +- help.hidden = allowPasswordsEngine || enginesListDisabled; + }); + // If fxAccountEnabled is false and we are in a "not configured" state, + // then fxAccounts is probably fully disabled rather than just unconfigured, + // so handle this case. This block can be removed once we remove support + // for fxAccounts being disabled. + } else if (Weave.Status.service == Weave.CLIENT_NOT_CONFIGURED || + Weave.Svc.Prefs.get("firstSync", "") == "notReady") { + this.page = PAGE_NO_ACCOUNT; +diff --git a/browser/components/preferences/in-content/sync.xul b/browser/components/preferences/in-content/sync.xul +--- a/browser/components/preferences/in-content/sync.xul ++++ b/browser/components/preferences/in-content/sync.xul +@@ -278,30 +278,19 @@ + <hbox id="fxaSyncEngines"> + <vbox> + <checkbox label="&engine.tabs.label;" + accesskey="&engine.tabs.accesskey;" + preference="engine.tabs"/> + <checkbox label="&engine.bookmarks.label;" + accesskey="&engine.bookmarks.accesskey;" + preference="engine.bookmarks"/> +- <hbox> +- <checkbox id="fxa-pweng-chk" +- label="&engine.passwords.label;" +- accesskey="&engine.passwords.accesskey;" +- preference="engine.passwords"/> +- +- <vbox id="fxa-pweng-help"> +- <spacer flex="1"/> +- <hbox id="fxa-pweng-help-link"> +- <image onclick="gSyncUtils.openMPInfoPage(event);" /> +- </hbox> +- <spacer flex="1"/> +- </vbox> +- </hbox> ++ <checkbox label="&engine.passwords.label;" ++ accesskey="&engine.passwords.accesskey;" ++ preference="engine.passwords"/> + <checkbox label="&engine.history.label;" + accesskey="&engine.history.accesskey;" + preference="engine.history"/> + <checkbox label="&engine.addons.label;" + accesskey="&engine.addons.accesskey;" + preference="engine.addons"/> + <checkbox label="&engine.prefs.label;" + accesskey="&engine.prefs.accesskey;" +diff --git a/browser/components/preferences/sync.js b/browser/components/preferences/sync.js +--- a/browser/components/preferences/sync.js ++++ b/browser/components/preferences/sync.js +@@ -149,27 +149,16 @@ let gSyncPane = { + document.getElementById("fxaEmailAddress1").textContent = data.email; + document.getElementById("fxaEmailAddress2").textContent = data.email; + document.getElementById("fxaEmailAddress3").textContent = data.email; + document.getElementById("fxaSyncComputerName").value = Weave.Service.clientsEngine.localName; + let engines = document.getElementById("fxaSyncEngines") + for (let checkbox of engines.querySelectorAll("checkbox")) { + checkbox.disabled = enginesListDisabled; + } +- +- let checkbox = document.getElementById("fxa-pweng-chk"); +- let help = document.getElementById("fxa-pweng-help"); +- let allowPasswordsEngine = service.allowPasswordsEngine; +- +- if (!allowPasswordsEngine) { +- checkbox.checked = false; +- } +- +- checkbox.disabled = !allowPasswordsEngine || enginesListDisabled; +- help.hidden = allowPasswordsEngine || enginesListDisabled; + }); + // If fxAccountEnabled is false and we are in a "not configured" state, + // then fxAccounts is probably fully disabled rather than just unconfigured, + // so handle this case. This block can be removed once we remove support + // for fxAccounts being disabled. + } else if (Weave.Status.service == Weave.CLIENT_NOT_CONFIGURED || + Weave.Svc.Prefs.get("firstSync", "") == "notReady") { + this.page = PAGE_NO_ACCOUNT; +diff --git a/browser/components/preferences/sync.xul b/browser/components/preferences/sync.xul +--- a/browser/components/preferences/sync.xul ++++ b/browser/components/preferences/sync.xul +@@ -260,30 +260,19 @@ + <hbox id="fxaSyncEngines"> + <vbox> + <checkbox label="&engine.tabs.label;" + accesskey="&engine.tabs.accesskey;" + preference="engine.tabs"/> + <checkbox label="&engine.bookmarks.label;" + accesskey="&engine.bookmarks.accesskey;" + preference="engine.bookmarks"/> +- <hbox> +- <checkbox id="fxa-pweng-chk" +- label="&engine.passwords.label;" +- accesskey="&engine.passwords.accesskey;" +- preference="engine.passwords"/> +- +- <vbox id="fxa-pweng-help"> +- <spacer flex="1"/> +- <hbox id="fxa-pweng-help-link"> +- <image onclick="gSyncUtils.openMPInfoPage(event);" /> +- </hbox> +- <spacer flex="1"/> +- </vbox> +- </hbox> ++ <checkbox label="&engine.passwords.label;" ++ accesskey="&engine.passwords.accesskey;" ++ preference="engine.passwords"/> + <checkbox label="&engine.history.label;" + accesskey="&engine.history.accesskey;" + preference="engine.history"/> + <checkbox label="&engine.addons.label;" + accesskey="&engine.addons.accesskey;" + preference="engine.addons"/> + <checkbox label="&engine.prefs.label;" + accesskey="&engine.prefs.accesskey;" +diff --git a/browser/themes/linux/preferences/preferences.css b/browser/themes/linux/preferences/preferences.css +--- a/browser/themes/linux/preferences/preferences.css ++++ b/browser/themes/linux/preferences/preferences.css +@@ -166,17 +166,9 @@ label.small { + margin: 5px; + line-height: 1.2em; + } + + #noFxaAccount > label:first-child { + margin-bottom: 0.6em; + } + +-#fxa-pweng-help-link > label { +- margin: 0; +-} +- +-#fxa-pweng-help-link > image { +- list-style-image: url("chrome://global/skin/icons/question-16.png"); +-} +- + %endif +diff --git a/browser/themes/osx/preferences/preferences.css b/browser/themes/osx/preferences/preferences.css +--- a/browser/themes/osx/preferences/preferences.css ++++ b/browser/themes/osx/preferences/preferences.css +@@ -228,25 +228,9 @@ html|a.inline-link:-moz-focusring { + margin: 12px 4px; + line-height: 1.2em; + } + + #noFxaAccount > label:first-child { + margin-bottom: 0.6em; + } + +-#fxa-pweng-help-link > label { +- margin: 0; +-} +- +-#fxa-pweng-help-link > image { +- width: 16px; +- height: 16px; +- list-style-image: url("chrome://global/skin/icons/question-16.png"); +-} +- +-@media (min-resolution: 2dppx) { +- #fxa-pweng-help-link > image { +- list-style-image: url("chrome://global/skin/icons/question-32.png"); +- } +-} +- + %endif +diff --git a/browser/themes/windows/preferences/preferences.css b/browser/themes/windows/preferences/preferences.css +--- a/browser/themes/windows/preferences/preferences.css ++++ b/browser/themes/windows/preferences/preferences.css +@@ -156,17 +156,9 @@ label.small { + margin: 6px; + line-height: 1.2em; + } + + #noFxaAccount > label:first-child { + margin-bottom: 0.6em; + } + +-#fxa-pweng-help-link > label { +- margin: 0; +-} +- +-#fxa-pweng-help-link > image { +- list-style-image: url("chrome://global/skin/icons/question-16.png"); +-} +- + %endif +diff --git a/services/sync/Weave.js b/services/sync/Weave.js +--- a/services/sync/Weave.js ++++ b/services/sync/Weave.js +@@ -104,26 +104,16 @@ WeaveService.prototype = { + let username = Services.prefs.getCharPref(SYNC_PREFS_BRANCH + "username"); + return !username || username.contains('@'); + } catch (_) { + return true; // No username == only allow FxA to be configured. + } + }, + + /** +- * Returns whether the password engine is allowed. We explicitly disallow +- * the password engine when a master password is used to ensure those can't +- * be accessed without the master key. +- */ +- get allowPasswordsEngine() { +- // This doesn't apply to old-style sync, it's only an issue for FxA. +- return !this.fxAccountsEnabled || !Utils.mpEnabled(); +- }, +- +- /** + * Whether Sync appears to be enabled. + * + * This returns true if all the Sync preferences for storing account + * and server configuration are populated. + * + * It does *not* perform a robust check to see if the client is working. + * For that, you'll want to check Weave.Status.checkSetup(). + */ +diff --git a/services/sync/modules/engines/passwords.js b/services/sync/modules/engines/passwords.js +--- a/services/sync/modules/engines/passwords.js ++++ b/services/sync/modules/engines/passwords.js +@@ -31,38 +31,16 @@ this.PasswordEngine = function PasswordE + } + PasswordEngine.prototype = { + __proto__: SyncEngine.prototype, + _storeObj: PasswordStore, + _trackerObj: PasswordTracker, + _recordObj: LoginRec, + applyIncomingBatchSize: PASSWORDS_STORE_BATCH_SIZE, + +- get isAllowed() { +- return Cc["@mozilla.org/weave/service;1"] +- .getService(Ci.nsISupports) +- .wrappedJSObject +- .allowPasswordsEngine; +- }, +- +- get enabled() { +- // If we are disabled due to !isAllowed(), we must take care to ensure the +- // engine has actually had the enabled setter called which reflects this state. +- let prefVal = SyncEngine.prototype.__lookupGetter__("enabled").call(this); +- let newVal = this.isAllowed && prefVal; +- if (newVal != prefVal) { +- this.enabled = newVal; +- } +- return newVal; +- }, +- +- set enabled(val) { +- SyncEngine.prototype.__lookupSetter__("enabled").call(this, this.isAllowed && val); +- }, +- + _syncFinish: function _syncFinish() { + SyncEngine.prototype._syncFinish.call(this); + + // Delete the weave credentials from the server once + if (!Svc.Prefs.get("deletePwdFxA", false)) { + try { + let ids = []; + for (let host of Utils.getSyncCredentialsHosts()) { +diff --git a/services/sync/tests/unit/test_password_mpenabled.js b/services/sync/tests/unit/test_password_mpenabled.js +deleted file mode 100644 +--- a/services/sync/tests/unit/test_password_mpenabled.js ++++ /dev/null +@@ -1,137 +0,0 @@ +-/* Any copyright is dedicated to the Public Domain.
+- http://creativecommons.org/publicdomain/zero/1.0/ */
+-
+-Cu.import("resource://gre/modules/Log.jsm");
+-Cu.import("resource://services-sync/stages/enginesync.js");
+-Cu.import("resource://services-sync/util.js");
+-Cu.import("resource://services-sync/engines/passwords.js");
+-Cu.import("resource://services-sync/service.js");
+-Cu.import("resource://testing-common/services/sync/utils.js");
+-
+-function run_test() {
+- initTestLogging("Trace");
+- run_next_test();
+-}
+-
+-add_test(function test_simple() {
+- ensureLegacyIdentityManager();
+- // Stub fxAccountsEnabled
+- let xpcs = Cc["@mozilla.org/weave/service;1"]
+- .getService(Components.interfaces.nsISupports)
+- .wrappedJSObject;
+- let fxaEnabledGetter = xpcs.__lookupGetter__("fxAccountsEnabled");
+- xpcs.__defineGetter__("fxAccountsEnabled", () => true);
+-
+- // Stub mpEnabled.
+- let mpEnabledF = Utils.mpEnabled;
+- let mpEnabled = false;
+- Utils.mpEnabled = function() mpEnabled;
+-
+- let manager = Service.engineManager;
+-
+- Service.engineManager.register(PasswordEngine);
+- let engine = Service.engineManager.get("passwords");
+- let wipeCount = 0;
+- let engineWipeServerF = engine.wipeServer;
+- engine.wipeServer = function() {
+- ++wipeCount;
+- }
+-
+- // A server for the metadata.
+- let server = new SyncServer();
+- let johndoe = server.registerUser("johndoe", "password");
+- johndoe.createContents({
+- meta: {global: {engines: {passwords: {version: engine.version,
+- syncID: engine.syncID}}}},
+- crypto: {},
+- clients: {}
+- });
+- server.start();
+- setBasicCredentials("johndoe", "password", "abcdeabcdeabcdeabcdeabcdea");
+- Service.serverURL = server.baseURI;
+- Service.clusterURL = server.baseURI;
+-
+- let engineSync = new EngineSynchronizer(Service);
+- engineSync._log.level = Log.Level.Trace;
+-
+- function assertEnabled(expected, message) {
+- Assert.strictEqual(engine.enabled, expected, message);
+- // The preference *must* reflect the actual state.
+- Assert.strictEqual(Svc.Prefs.get("engine." + engine.prefName), expected,
+- message + " (pref should match enabled state)");
+- }
+-
+- try {
+- assertEnabled(true, "password engine should be enabled by default")
+- let engineMeta = Service.recordManager.get(engine.metaURL);
+- // This engine should be in the meta/global
+- Assert.notStrictEqual(engineMeta.payload.engines[engine.name], undefined,
+- "The engine should appear in the metadata");
+- Assert.ok(!engineMeta.changed, "the metadata for the password engine hasn't changed");
+-
+- // (pretend to) enable a master-password
+- mpEnabled = true;
+- // The password engine should be locally disabled...
+- assertEnabled(false, "if mp is locked the engine should be disabled");
+- // ...but not declined.
+- Assert.ok(!manager.isDeclined("passwords"), "password engine is not declined");
+- // Next time a sync would happen, we call _updateEnabledEngines(), which
+- // would remove the engine from the metadata - call that now.
+- engineSync._updateEnabledEngines();
+- // The global meta should no longer list the engine.
+- engineMeta = Service.recordManager.get(engine.metaURL);
+- Assert.strictEqual(engineMeta.payload.engines[engine.name], undefined,
+- "The engine should have vanished");
+- // And we should have wiped the server data.
+- Assert.strictEqual(wipeCount, 1, "wipeServer should have been called");
+-
+- // Now simulate an incoming meta/global indicating the engine should be
+- // enabled. We should fail to actually enable it - the pref should remain
+- // false and we wipe the server for anything another device might have
+- // stored.
+- let meta = {
+- payload: {
+- engines: {
+- "passwords": {"version":1,"syncID":"yfBi2v7PpFO2"},
+- },
+- },
+- };
+- engineSync._updateEnabledFromMeta(meta, 3, manager);
+- Assert.strictEqual(wipeCount, 2, "wipeServer should have been called");
+- Assert.ok(!manager.isDeclined("passwords"), "password engine is not declined");
+- assertEnabled(false, "engine still not enabled locally");
+-
+- // Let's turn the MP off - but *not* re-enable it locally.
+- mpEnabled = false;
+- // Just disabling the MP isn't enough to force it back to enabled.
+- assertEnabled(false, "engine still not enabled locally");
+- // Another incoming metadata record with the engine enabled should cause
+- // it to be enabled locally.
+- meta = {
+- payload: {
+- engines: {
+- "passwords": 1,
+- },
+- },
+- };
+- engineSync._updateEnabledFromMeta(meta, 3, manager);
+- Assert.strictEqual(wipeCount, 2, "wipeServer should *not* have been called again");
+- Assert.ok(!manager.isDeclined("passwords"), "password engine is not declined");
+- // It should be enabled locally.
+- assertEnabled(true, "engine now enabled locally");
+- // Next time a sync starts it should magically re-appear in our meta/global
+- engine._syncStartup();
+- //engineSync._updateEnabledEngines();
+- engineMeta = Service.recordManager.get(engine.metaURL);
+- Assert.equal(engineMeta.payload.engines[engine.name].version, engine.version,
+- "The engine should re-appear in the metadata");
+- } finally {
+- // restore the damage we did above...
+- engine.wipeServer = engineWipeServerF;
+- engine._store.wipe();
+- // Un-stub mpEnabled and fxAccountsEnabled
+- Utils.mpEnabled = mpEnabledF;
+- xpcs.__defineGetter__("fxAccountsEnabled", fxaEnabledGetter);
+- server.stop(run_next_test);
+- }
+-});
+diff --git a/services/sync/tests/unit/xpcshell.ini b/services/sync/tests/unit/xpcshell.ini +--- a/services/sync/tests/unit/xpcshell.ini ++++ b/services/sync/tests/unit/xpcshell.ini +@@ -164,10 +164,8 @@ skip-if = debug + [test_prefs_store.js] + [test_prefs_tracker.js] + [test_tab_engine.js] + [test_tab_store.js] + [test_tab_tracker.js] + + [test_healthreport.js] + skip-if = ! healthreport +- +-[test_password_mpenabled.js] diff --git a/data/patches/disable/0001-upgrade-mobile-fxa-to-v32.patch b/data/patches/disable/0001-upgrade-mobile-fxa-to-v32.patch new file mode 100644 index 0000000..e420727 --- /dev/null +++ b/data/patches/disable/0001-upgrade-mobile-fxa-to-v32.patch @@ -0,0 +1,992 @@ +diff -ruN mozilla-esr31/mobile/android/base/fxa/FirefoxAccounts.java mozilla-release/mobile/android/base/fxa/FirefoxAccounts.java +--- mozilla-esr31/mobile/android/base/fxa/FirefoxAccounts.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/FirefoxAccounts.java 2014-09-24 03:05:32.000000000 +0200 +@@ -6,13 +6,18 @@ + + import java.io.File; + import java.util.EnumSet; ++import java.util.Locale; + import java.util.concurrent.CountDownLatch; + ++import org.mozilla.gecko.AppConstants; ++import org.mozilla.gecko.R; + import org.mozilla.gecko.background.common.log.Logger; + import org.mozilla.gecko.fxa.authenticator.AccountPickler; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; ++import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.sync.FxAccountSyncAdapter; + import org.mozilla.gecko.fxa.sync.FxAccountSyncStatusHelper; ++import org.mozilla.gecko.fxa.tasks.FxAccountCodeResender; + import org.mozilla.gecko.sync.ThreadPool; + import org.mozilla.gecko.sync.Utils; + +@@ -20,6 +25,7 @@ + import android.accounts.AccountManager; + import android.content.ContentResolver; + import android.content.Context; ++import android.content.res.Resources; + import android.os.Bundle; + + /** +@@ -152,6 +158,38 @@ + return null; + } + ++ /** ++ * @return ++ * the {@link State} instance associated with the current account, or <code>null</code> if ++ * no accounts exist. ++ */ ++ public static State getFirefoxAccountState(final Context context) { ++ final Account account = getFirefoxAccount(context); ++ if (account == null) { ++ return null; ++ } ++ ++ final AndroidFxAccount fxAccount = new AndroidFxAccount(context, account); ++ try { ++ return fxAccount.getState(); ++ } catch (final Exception ex) { ++ Logger.warn(LOG_TAG, "Could not get FX account state.", ex); ++ return null; ++ } ++ } ++ ++ /* ++ * @param context Android context ++ * @return the email address associated with the configured Firefox account if one exists; null otherwise. ++ */ ++ public static String getFirefoxAccountEmail(final Context context) { ++ final Account account = getFirefoxAccount(context); ++ if (account == null) { ++ return null; ++ } ++ return account.name; ++ } ++ + protected static void putHintsToSync(final Bundle extras, EnumSet<SyncHint> syncHints) { + // stagesToSync and stagesToSkip are allowed to be null. + if (syncHints == null) { +@@ -264,4 +302,33 @@ + // stopObserving null-checks its argument. + FxAccountSyncStatusHelper.getInstance().stopObserving(syncStatusListener); + } ++ ++ public static String getOldSyncUpgradeURL(final Resources res, final Locale locale) { ++ final String VERSION = AppConstants.MOZ_APP_VERSION; ++ final String OS = AppConstants.OS_TARGET; ++ final String LOCALE = Utils.getLanguageTag(locale); ++ return res.getString(R.string.fxaccount_link_old_firefox, VERSION, OS, LOCALE); ++ } ++ ++ /** ++ * Resends the account verification email, and displays an appropriate ++ * toast on both send success and failure. Note that because the underlying implementation ++ * uses {@link AsyncTask}, the provided context must be UI-capable, and this ++ * method called from the UI thread (see ++ * {@link org.mozilla.gecko.fxa.tasks.FxAccountCodeResender#resendCode(Context, AndroidFxAccount)} ++ * for more). ++ * ++ * @param context a UI-capable Android context. ++ * @return true if an account exists, false otherwise. ++ */ ++ public static boolean resendVerificationEmail(final Context context) { ++ final Account account = getFirefoxAccount(context); ++ if (account == null) { ++ return false; ++ } ++ ++ final AndroidFxAccount fxAccount = new AndroidFxAccount(context, account); ++ FxAccountCodeResender.resendCode(context, fxAccount); ++ return true; ++ } + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -19,10 +19,10 @@ + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.background.fxa.QuickPasswordStretcher; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.ProgressDisplay; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; + import org.mozilla.gecko.fxa.login.Engaged; + import org.mozilla.gecko.fxa.login.State; ++import org.mozilla.gecko.fxa.tasks.FxAccountSetupTask.ProgressDisplay; + import org.mozilla.gecko.sync.SyncConfiguration; + import org.mozilla.gecko.sync.setup.Constants; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -4,21 +4,15 @@ + + package org.mozilla.gecko.fxa.activities; + +-import java.util.concurrent.Executor; +-import java.util.concurrent.Executors; +- + import org.mozilla.gecko.R; + import org.mozilla.gecko.background.common.log.Logger; +-import org.mozilla.gecko.background.fxa.FxAccountClient; +-import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; +-import org.mozilla.gecko.background.fxa.FxAccountClient20; +-import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; + import org.mozilla.gecko.fxa.FirefoxAccounts; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; + import org.mozilla.gecko.fxa.login.Engaged; + import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.login.State.Action; + import org.mozilla.gecko.fxa.sync.FxAccountSyncStatusHelper; ++import org.mozilla.gecko.fxa.tasks.FxAccountCodeResender; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + + import android.accounts.Account; +@@ -28,7 +22,6 @@ + import android.view.View; + import android.view.View.OnClickListener; + import android.widget.TextView; +-import android.widget.Toast; + + /** + * Activity which displays account created successfully screen to the user, and +@@ -164,76 +157,8 @@ + resendLink.setClickable(resendLinkShouldBeEnabled); + } + +- public static class FxAccountResendCodeTask extends FxAccountSetupTask<Void> { +- protected static final String LOG_TAG = FxAccountResendCodeTask.class.getSimpleName(); +- +- protected final byte[] sessionToken; +- +- public FxAccountResendCodeTask(Context context, byte[] sessionToken, FxAccountClient client, RequestDelegate<Void> delegate) { +- super(context, null, client, delegate); +- this.sessionToken = sessionToken; +- } +- +- @Override +- protected InnerRequestDelegate<Void> doInBackground(Void... arg0) { +- try { +- client.resendCode(sessionToken, innerDelegate); +- latch.await(); +- return innerDelegate; +- } catch (Exception e) { +- Logger.error(LOG_TAG, "Got exception signing in.", e); +- delegate.handleError(e); +- } +- return null; +- } +- } +- +- protected static class ResendCodeDelegate implements RequestDelegate<Void> { +- public final Context context; +- +- public ResendCodeDelegate(Context context) { +- this.context = context; +- } +- +- @Override +- public void handleError(Exception e) { +- Logger.warn(LOG_TAG, "Got exception requesting fresh confirmation link; ignoring.", e); +- Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_not_sent, Toast.LENGTH_LONG).show(); +- } +- +- @Override +- public void handleFailure(FxAccountClientRemoteException e) { +- handleError(e); +- } +- +- @Override +- public void handleSuccess(Void result) { +- Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_sent, Toast.LENGTH_SHORT).show(); +- } +- } +- +- public static void resendCode(Context context, AndroidFxAccount fxAccount) { +- RequestDelegate<Void> delegate = new ResendCodeDelegate(context); +- +- byte[] sessionToken; +- try { +- sessionToken = ((Engaged) fxAccount.getState()).getSessionToken(); +- } catch (Exception e) { +- delegate.handleError(e); +- return; +- } +- if (sessionToken == null) { +- delegate.handleError(new IllegalStateException("sessionToken should not be null")); +- return; +- } +- +- Executor executor = Executors.newSingleThreadExecutor(); +- FxAccountClient client = new FxAccountClient20(fxAccount.getAccountServerURI(), executor); +- new FxAccountResendCodeTask(context, sessionToken, client, delegate).execute(); +- } +- + @Override + public void onClick(View v) { +- resendCode(this, fxAccount); ++ FxAccountCodeResender.resendCode(this, fxAccount); + } + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -21,7 +21,7 @@ + import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.FxAccountCreateAccountTask; ++import org.mozilla.gecko.fxa.tasks.FxAccountCreateAccountTask; + + import android.app.AlertDialog; + import android.app.Dialog; +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -6,13 +6,11 @@ + + import java.util.Locale; + +-import org.mozilla.gecko.AppConstants; + import org.mozilla.gecko.R; + import org.mozilla.gecko.background.common.log.Logger; + import org.mozilla.gecko.background.fxa.FxAccountAgeLockoutHelper; + import org.mozilla.gecko.fxa.FirefoxAccounts; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.sync.Utils; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + import org.mozilla.gecko.sync.setup.activities.LocaleAware; + +@@ -109,11 +107,7 @@ + protected void linkifyOldFirefoxLink() { + TextView oldFirefox = (TextView) findViewById(R.id.old_firefox); + String text = getResources().getString(R.string.fxaccount_getting_started_old_firefox); +- String VERSION = AppConstants.MOZ_APP_VERSION; +- String OS = AppConstants.OS_TARGET; +- +- String LOCALE = Utils.getLanguageTag(Locale.getDefault()); +- String url = getResources().getString(R.string.fxaccount_link_old_firefox, VERSION, OS, LOCALE); ++ final String url = FirefoxAccounts.getOldSyncUpgradeURL(getResources(), Locale.getDefault()); + FxAccountConstants.pii(LOG_TAG, "Old Firefox url is: " + url); // Don't want to leak locale in particular. + ActivityUtils.linkTextView(oldFirefox, text, url); + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSetupTask.java mozilla-release/mobile/android/base/fxa/activities/FxAccountSetupTask.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSetupTask.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountSetupTask.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,172 +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/. */ +- +-package org.mozilla.gecko.fxa.activities; +- +-import java.io.UnsupportedEncodingException; +-import java.util.concurrent.CountDownLatch; +- +-import org.mozilla.gecko.background.common.log.Logger; +-import org.mozilla.gecko.background.fxa.FxAccountClient; +-import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; +-import org.mozilla.gecko.background.fxa.FxAccountClient20.LoginResponse; +-import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; +-import org.mozilla.gecko.background.fxa.PasswordStretcher; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.InnerRequestDelegate; +- +-import android.content.Context; +-import android.os.AsyncTask; +- +-/** +- * An <code>AsyncTask</code> wrapper around signing up for, and signing in to, a +- * Firefox Account. +- * <p> +- * It's strange to add explicit blocking to callback-threading code, but we do +- * it here to take advantage of Android's built in support for background work. +- * We really want to avoid making a threading mistake that brings down the whole +- * process. +- */ +-abstract class FxAccountSetupTask<T> extends AsyncTask<Void, Void, InnerRequestDelegate<T>> { +- private static final String LOG_TAG = FxAccountSetupTask.class.getSimpleName(); +- +- public interface ProgressDisplay { +- public void showProgress(); +- public void dismissProgress(); +- } +- +- protected final Context context; +- protected final FxAccountClient client; +- protected final ProgressDisplay progressDisplay; +- +- // Initialized lazily. +- protected byte[] quickStretchedPW; +- +- // AsyncTask's are one-time-use, so final members are fine. +- protected final CountDownLatch latch = new CountDownLatch(1); +- protected final InnerRequestDelegate<T> innerDelegate = new InnerRequestDelegate<T>(latch); +- +- protected final RequestDelegate<T> delegate; +- +- public FxAccountSetupTask(Context context, ProgressDisplay progressDisplay, FxAccountClient client, RequestDelegate<T> delegate) { +- this.context = context; +- this.client = client; +- this.delegate = delegate; +- this.progressDisplay = progressDisplay; +- } +- +- @Override +- protected void onPreExecute() { +- if (progressDisplay != null) { +- progressDisplay.showProgress(); +- } +- } +- +- @Override +- protected void onPostExecute(InnerRequestDelegate<T> result) { +- if (progressDisplay != null) { +- progressDisplay.dismissProgress(); +- } +- +- // We are on the UI thread, and need to invoke these callbacks here to allow UI updating. +- if (innerDelegate.failure != null) { +- delegate.handleFailure(innerDelegate.failure); +- } else if (innerDelegate.exception != null) { +- delegate.handleError(innerDelegate.exception); +- } else { +- delegate.handleSuccess(result.response); +- } +- } +- +- @Override +- protected void onCancelled(InnerRequestDelegate<T> result) { +- if (progressDisplay != null) { +- progressDisplay.dismissProgress(); +- } +- delegate.handleError(new IllegalStateException("Task was cancelled.")); +- } +- +- protected static class InnerRequestDelegate<T> implements RequestDelegate<T> { +- protected final CountDownLatch latch; +- public T response = null; +- public Exception exception = null; +- public FxAccountClientRemoteException failure = null; +- +- protected InnerRequestDelegate(CountDownLatch latch) { +- this.latch = latch; +- } +- +- @Override +- public void handleError(Exception e) { +- Logger.error(LOG_TAG, "Got exception."); +- this.exception = e; +- latch.countDown(); +- } +- +- @Override +- public void handleFailure(FxAccountClientRemoteException e) { +- Logger.warn(LOG_TAG, "Got failure."); +- this.failure = e; +- latch.countDown(); +- } +- +- @Override +- public void handleSuccess(T result) { +- Logger.info(LOG_TAG, "Got success."); +- this.response = result; +- latch.countDown(); +- } +- } +- +- public static class FxAccountCreateAccountTask extends FxAccountSetupTask<LoginResponse> { +- private static final String LOG_TAG = FxAccountCreateAccountTask.class.getSimpleName(); +- +- protected final byte[] emailUTF8; +- protected final PasswordStretcher passwordStretcher; +- +- public FxAccountCreateAccountTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { +- super(context, progressDisplay, client, delegate); +- this.emailUTF8 = email.getBytes("UTF-8"); +- this.passwordStretcher = passwordStretcher; +- } +- +- @Override +- protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { +- try { +- client.createAccountAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); +- latch.await(); +- return innerDelegate; +- } catch (Exception e) { +- Logger.error(LOG_TAG, "Got exception logging in.", e); +- delegate.handleError(e); +- } +- return null; +- } +- } +- +- public static class FxAccountSignInTask extends FxAccountSetupTask<LoginResponse> { +- protected static final String LOG_TAG = FxAccountSignInTask.class.getSimpleName(); +- +- protected final byte[] emailUTF8; +- protected final PasswordStretcher passwordStretcher; +- +- public FxAccountSignInTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { +- super(context, progressDisplay, client, delegate); +- this.emailUTF8 = email.getBytes("UTF-8"); +- this.passwordStretcher = passwordStretcher; +- } +- +- @Override +- protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { +- try { +- client.loginAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); +- latch.await(); +- return innerDelegate; +- } catch (Exception e) { +- Logger.error(LOG_TAG, "Got exception signing in.", e); +- delegate.handleError(e); +- } +- return null; +- } +- } +-} +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSignInActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountSignInActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSignInActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountSignInActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -16,7 +16,7 @@ + import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.FxAccountSignInTask; ++import org.mozilla.gecko.fxa.tasks.FxAccountSignInTask; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + + import android.content.Intent; +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountStatusFragment.java mozilla-release/mobile/android/base/fxa/activities/FxAccountStatusFragment.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountStatusFragment.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountStatusFragment.java 2014-09-24 03:05:32.000000000 +0200 +@@ -17,6 +17,8 @@ + import org.mozilla.gecko.fxa.login.Married; + import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.sync.FxAccountSyncStatusHelper; ++import org.mozilla.gecko.fxa.tasks.FxAccountCodeResender; ++import org.mozilla.gecko.sync.SharedPreferencesClientsDataDelegate; + import org.mozilla.gecko.sync.SyncConfiguration; + + import android.accounts.Account; +@@ -27,10 +29,13 @@ + import android.os.Bundle; + import android.os.Handler; + import android.preference.CheckBoxPreference; ++import android.preference.EditTextPreference; + import android.preference.Preference; ++import android.preference.Preference.OnPreferenceChangeListener; + import android.preference.Preference.OnPreferenceClickListener; + import android.preference.PreferenceCategory; + import android.preference.PreferenceScreen; ++import android.text.TextUtils; + + /** + * A fragment that displays the status of an AndroidFxAccount. +@@ -38,7 +43,9 @@ + * The owning activity is responsible for providing an AndroidFxAccount at + * appropriate times. + */ +-public class FxAccountStatusFragment extends PreferenceFragment implements OnPreferenceClickListener { ++public class FxAccountStatusFragment ++ extends PreferenceFragment ++ implements OnPreferenceClickListener, OnPreferenceChangeListener { + private static final String LOG_TAG = FxAccountStatusFragment.class.getSimpleName(); + + // When a checkbox is toggled, wait 5 seconds (for other checkbox actions) +@@ -64,7 +71,12 @@ + protected CheckBoxPreference tabsPreference; + protected CheckBoxPreference passwordsPreference; + ++ protected EditTextPreference deviceNamePreference; ++ + protected volatile AndroidFxAccount fxAccount; ++ // The contract is: when fxAccount is non-null, then clientsDataDelegate is ++ // non-null. If violated then an IllegalStateException is thrown. ++ protected volatile SharedPreferencesClientsDataDelegate clientsDataDelegate; + + // Used to post delayed sync requests. + protected Handler handler; +@@ -87,6 +99,10 @@ + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); ++ addPreferences(); ++ } ++ ++ protected void addPreferences() { + addPreferencesFromResource(R.xml.fxaccount_status_prefscreen); + + emailPreference = ensureFindPreference("email"); +@@ -118,6 +134,9 @@ + historyPreference.setOnPreferenceClickListener(this); + tabsPreference.setOnPreferenceClickListener(this); + passwordsPreference.setOnPreferenceClickListener(this); ++ ++ deviceNamePreference = (EditTextPreference) ensureFindPreference("device_name"); ++ deviceNamePreference.setOnPreferenceChangeListener(this); + } + + /** +@@ -142,7 +161,7 @@ + } + + if (preference == needsVerificationPreference) { +- FxAccountConfirmAccountActivity.resendCode(getActivity().getApplicationContext(), fxAccount); ++ FxAccountCodeResender.resendCode(getActivity().getApplicationContext(), fxAccount); + + Intent intent = new Intent(getActivity(), FxAccountConfirmAccountActivity.class); + // Per http://stackoverflow.com/a/8992365, this triggers a known bug with +@@ -176,6 +195,8 @@ + historyPreference.setEnabled(enabled); + tabsPreference.setEnabled(enabled); + passwordsPreference.setEnabled(enabled); ++ // Since we can't sync, we can't update our remote client record. ++ deviceNamePreference.setEnabled(enabled); + } + + /** +@@ -293,6 +314,14 @@ + throw new IllegalArgumentException("fxAccount must not be null"); + } + this.fxAccount = fxAccount; ++ try { ++ this.clientsDataDelegate = new SharedPreferencesClientsDataDelegate(fxAccount.getSyncPrefs()); ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception fetching Sync prefs associated to Firefox Account; aborting.", e); ++ // Something is terribly wrong; best to get a stack trace rather than ++ // continue with a null clients delegate. ++ throw new IllegalStateException(e); ++ } + + handler = new Handler(); // Attached to current (assumed to be UI) thread. + +@@ -318,6 +347,17 @@ + FxAccountSyncStatusHelper.getInstance().stopObserving(syncStatusDelegate); + } + ++ protected void hardRefresh() { ++ // This is the only way to guarantee that the EditText dialogs created by ++ // EditTextPreferences are re-created. This works around the issue described ++ // at http://androiddev.orkitra.com/?p=112079. ++ final PreferenceScreen statusScreen = (PreferenceScreen) ensureFindPreference("status_screen"); ++ statusScreen.removeAll(); ++ addPreferences(); ++ ++ refresh(); ++ } ++ + protected void refresh() { + // refresh is called from our onResume, which can happen before the owning + // Activity tells us about an account (via our public +@@ -371,6 +411,10 @@ + // No matter our state, we should update the checkboxes. + updateSelectedEngines(); + } ++ ++ final String clientName = clientsDataDelegate.getClientName(); ++ deviceNamePreference.setSummary(clientName); ++ deviceNamePreference.setText(clientName); + } + + /** +@@ -570,4 +614,22 @@ + button.setOnPreferenceClickListener(listener); + } + } ++ ++ @Override ++ public boolean onPreferenceChange(Preference preference, Object newValue) { ++ if (preference == deviceNamePreference) { ++ String newClientName = (String) newValue; ++ if (TextUtils.isEmpty(newClientName)) { ++ newClientName = clientsDataDelegate.getDefaultClientName(); ++ } ++ final long now = System.currentTimeMillis(); ++ clientsDataDelegate.setClientName(newClientName, now); ++ requestDelayedSync(); // Try to update our remote client record. ++ hardRefresh(); // Updates the value displayed to the user, among other things. ++ return true; ++ } ++ ++ // For everything else, accept the change. ++ return true; ++ } + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -18,11 +18,11 @@ + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.fxa.FirefoxAccounts; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.FxAccountSignInTask; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; + import org.mozilla.gecko.fxa.login.Engaged; + import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.login.State.StateLabel; ++import org.mozilla.gecko.fxa.tasks.FxAccountSignInTask; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + + import android.os.Bundle; +diff -ruN mozilla-esr31/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java mozilla-release/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java +--- mozilla-esr31/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java 2014-09-24 03:05:33.000000000 +0200 +@@ -357,7 +357,11 @@ + + FxAccountGlobalSession globalSession = null; + try { +- ClientsDataDelegate clientsDataDelegate = new SharedPreferencesClientsDataDelegate(sharedPrefs); ++ final ClientsDataDelegate clientsDataDelegate = new SharedPreferencesClientsDataDelegate(sharedPrefs); ++ if (FxAccountConstants.LOG_PERSONAL_INFORMATION) { ++ FxAccountConstants.pii(LOG_TAG, "Client device name is: '" + clientsDataDelegate.getClientName() + "'."); ++ FxAccountConstants.pii(LOG_TAG, "Client device data last modified: " + clientsDataDelegate.getLastModifiedTimestamp()); ++ } + + // We compute skew over time using SkewHandler. This yields an unchanging + // skew adjustment that the HawkAuthHeaderProvider uses to adjust its +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCodeResender.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountCodeResender.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCodeResender.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountCodeResender.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,108 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.util.concurrent.Executor; ++import java.util.concurrent.Executors; ++ ++import org.mozilla.gecko.R; ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClient20; ++import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; ++import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; ++import org.mozilla.gecko.fxa.login.Engaged; ++ ++import android.content.Context; ++import android.widget.Toast; ++ ++/** ++ * A helper class that provides a simple interface for requesting ++ * a Firefox Account verification email to be resent. ++ */ ++public class FxAccountCodeResender { ++ private static final String LOG_TAG = FxAccountCodeResender.class.getSimpleName(); ++ ++ private static class FxAccountResendCodeTask extends FxAccountSetupTask<Void> { ++ protected static final String LOG_TAG = FxAccountResendCodeTask.class.getSimpleName(); ++ ++ protected final byte[] sessionToken; ++ ++ public FxAccountResendCodeTask(Context context, byte[] sessionToken, FxAccountClient client, RequestDelegate<Void> delegate) { ++ super(context, null, client, delegate); ++ this.sessionToken = sessionToken; ++ } ++ ++ @Override ++ protected InnerRequestDelegate<Void> doInBackground(Void... arg0) { ++ try { ++ client.resendCode(sessionToken, innerDelegate); ++ latch.await(); ++ return innerDelegate; ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception signing in.", e); ++ delegate.handleError(e); ++ } ++ return null; ++ } ++ } ++ ++ private static class ResendCodeDelegate implements RequestDelegate<Void> { ++ public final Context context; ++ ++ public ResendCodeDelegate(Context context) { ++ this.context = context; ++ } ++ ++ @Override ++ public void handleError(Exception e) { ++ Logger.warn(LOG_TAG, "Got exception requesting fresh confirmation link; ignoring.", e); ++ Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_not_sent, Toast.LENGTH_LONG).show(); ++ } ++ ++ @Override ++ public void handleFailure(FxAccountClientRemoteException e) { ++ handleError(e); ++ } ++ ++ @Override ++ public void handleSuccess(Void result) { ++ Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_sent, Toast.LENGTH_SHORT).show(); ++ } ++ } ++ ++ /** ++ * Resends the account verification email, and displays an appropriate ++ * toast on both send success and failure. Note that because the underlying implementation ++ * uses {@link AsyncTask}, the provided context must be UI-capable and ++ * this method called from the UI thread. ++ * ++ * Note that it may actually be possible to run this (and the {@link AsyncTask}) method ++ * from a background thread - but this hasn't been tested. ++ * ++ * @param context A UI-capable Android context. ++ * @param fxAccount The Firefox Account to resend the code to. ++ */ ++ public static void resendCode(Context context, AndroidFxAccount fxAccount) { ++ RequestDelegate<Void> delegate = new ResendCodeDelegate(context); ++ ++ byte[] sessionToken; ++ try { ++ sessionToken = ((Engaged) fxAccount.getState()).getSessionToken(); ++ } catch (Exception e) { ++ delegate.handleError(e); ++ return; ++ } ++ if (sessionToken == null) { ++ delegate.handleError(new IllegalStateException("sessionToken should not be null")); ++ return; ++ } ++ ++ Executor executor = Executors.newSingleThreadExecutor(); ++ FxAccountClient client = new FxAccountClient20(fxAccount.getAccountServerURI(), executor); ++ new FxAccountResendCodeTask(context, sessionToken, client, delegate).execute(); ++ } ++} +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,41 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.io.UnsupportedEncodingException; ++ ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClient20.LoginResponse; ++import org.mozilla.gecko.background.fxa.PasswordStretcher; ++ ++import android.content.Context; ++ ++public class FxAccountCreateAccountTask extends FxAccountSetupTask<LoginResponse> { ++ private static final String LOG_TAG = FxAccountCreateAccountTask.class.getSimpleName(); ++ ++ protected final byte[] emailUTF8; ++ protected final PasswordStretcher passwordStretcher; ++ ++ public FxAccountCreateAccountTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { ++ super(context, progressDisplay, client, delegate); ++ this.emailUTF8 = email.getBytes("UTF-8"); ++ this.passwordStretcher = passwordStretcher; ++ } ++ ++ @Override ++ protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { ++ try { ++ client.createAccountAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); ++ latch.await(); ++ return innerDelegate; ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception logging in.", e); ++ delegate.handleError(e); ++ } ++ return null; ++ } ++} +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSetupTask.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountSetupTask.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSetupTask.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountSetupTask.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,117 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.util.concurrent.CountDownLatch; ++ ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; ++import org.mozilla.gecko.fxa.tasks.FxAccountSetupTask.InnerRequestDelegate; ++ ++import android.content.Context; ++import android.os.AsyncTask; ++ ++/** ++ * An <code>AsyncTask</code> wrapper around signing up for, and signing in to, a ++ * Firefox Account. ++ * <p> ++ * It's strange to add explicit blocking to callback-threading code, but we do ++ * it here to take advantage of Android's built in support for background work. ++ * We really want to avoid making a threading mistake that brings down the whole ++ * process. ++ */ ++public abstract class FxAccountSetupTask<T> extends AsyncTask<Void, Void, InnerRequestDelegate<T>> { ++ private static final String LOG_TAG = FxAccountSetupTask.class.getSimpleName(); ++ ++ public interface ProgressDisplay { ++ public void showProgress(); ++ public void dismissProgress(); ++ } ++ ++ protected final Context context; ++ protected final FxAccountClient client; ++ protected final ProgressDisplay progressDisplay; ++ ++ // Initialized lazily. ++ protected byte[] quickStretchedPW; ++ ++ // AsyncTask's are one-time-use, so final members are fine. ++ protected final CountDownLatch latch = new CountDownLatch(1); ++ protected final InnerRequestDelegate<T> innerDelegate = new InnerRequestDelegate<T>(latch); ++ ++ protected final RequestDelegate<T> delegate; ++ ++ public FxAccountSetupTask(Context context, ProgressDisplay progressDisplay, FxAccountClient client, RequestDelegate<T> delegate) { ++ this.context = context; ++ this.client = client; ++ this.delegate = delegate; ++ this.progressDisplay = progressDisplay; ++ } ++ ++ @Override ++ protected void onPreExecute() { ++ if (progressDisplay != null) { ++ progressDisplay.showProgress(); ++ } ++ } ++ ++ @Override ++ protected void onPostExecute(InnerRequestDelegate<T> result) { ++ if (progressDisplay != null) { ++ progressDisplay.dismissProgress(); ++ } ++ ++ // We are on the UI thread, and need to invoke these callbacks here to allow UI updating. ++ if (innerDelegate.failure != null) { ++ delegate.handleFailure(innerDelegate.failure); ++ } else if (innerDelegate.exception != null) { ++ delegate.handleError(innerDelegate.exception); ++ } else { ++ delegate.handleSuccess(result.response); ++ } ++ } ++ ++ @Override ++ protected void onCancelled(InnerRequestDelegate<T> result) { ++ if (progressDisplay != null) { ++ progressDisplay.dismissProgress(); ++ } ++ delegate.handleError(new IllegalStateException("Task was cancelled.")); ++ } ++ ++ protected static class InnerRequestDelegate<T> implements RequestDelegate<T> { ++ protected final CountDownLatch latch; ++ public T response = null; ++ public Exception exception = null; ++ public FxAccountClientRemoteException failure = null; ++ ++ protected InnerRequestDelegate(CountDownLatch latch) { ++ this.latch = latch; ++ } ++ ++ @Override ++ public void handleError(Exception e) { ++ Logger.error(LOG_TAG, "Got exception."); ++ this.exception = e; ++ latch.countDown(); ++ } ++ ++ @Override ++ public void handleFailure(FxAccountClientRemoteException e) { ++ Logger.warn(LOG_TAG, "Got failure."); ++ this.failure = e; ++ latch.countDown(); ++ } ++ ++ @Override ++ public void handleSuccess(T result) { ++ Logger.info(LOG_TAG, "Got success."); ++ this.response = result; ++ latch.countDown(); ++ } ++ } ++} +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSignInTask.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountSignInTask.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSignInTask.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountSignInTask.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,41 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.io.UnsupportedEncodingException; ++ ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClient20.LoginResponse; ++import org.mozilla.gecko.background.fxa.PasswordStretcher; ++ ++import android.content.Context; ++ ++public class FxAccountSignInTask extends FxAccountSetupTask<LoginResponse> { ++ protected static final String LOG_TAG = FxAccountSignInTask.class.getSimpleName(); ++ ++ protected final byte[] emailUTF8; ++ protected final PasswordStretcher passwordStretcher; ++ ++ public FxAccountSignInTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { ++ super(context, progressDisplay, client, delegate); ++ this.emailUTF8 = email.getBytes("UTF-8"); ++ this.passwordStretcher = passwordStretcher; ++ } ++ ++ @Override ++ protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { ++ try { ++ client.loginAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); ++ latch.await(); ++ return innerDelegate; ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception signing in.", e); ++ delegate.handleError(e); ++ } ++ return null; ++ } ++} +--- mozilla-esr31/mobile/android/base/android-services.mozbuild 2015-02-25 19:21:05.000000000 +0100 ++++ mozilla-release/mobile/android/base/android-services.mozbuild 2014-09-24 03:05:32.000000000 +0200 +@@ -555,7 +557,6 @@ + 'fxa/activities/FxAccountCreateAccountActivity.java', + 'fxa/activities/FxAccountCreateAccountNotAllowedActivity.java', + 'fxa/activities/FxAccountGetStartedActivity.java', +- 'fxa/activities/FxAccountSetupTask.java', + 'fxa/activities/FxAccountSignInActivity.java', + 'fxa/activities/FxAccountStatusActivity.java', + 'fxa/activities/FxAccountStatusFragment.java', +@@ -589,6 +590,10 @@ + 'fxa/sync/FxAccountSyncService.java', + 'fxa/sync/FxAccountSyncStatusHelper.java', + 'fxa/sync/SchedulePolicy.java', ++ 'fxa/tasks/FxAccountCodeResender.java', ++ 'fxa/tasks/FxAccountCreateAccountTask.java', ++ 'fxa/tasks/FxAccountSetupTask.java', ++ 'fxa/tasks/FxAccountSignInTask.java', + 'sync/AlreadySyncingException.java', + 'sync/BackoffHandler.java', + 'sync/BadRequiredFieldJSONException.java', diff --git a/data/patches/disable/0002-update-mobile-sqlite-to-v35.patch b/data/patches/disable/0002-update-mobile-sqlite-to-v35.patch new file mode 100644 index 0000000..9a99ea2 --- /dev/null +++ b/data/patches/disable/0002-update-mobile-sqlite-to-v35.patch @@ -0,0 +1,246 @@ +diff -ru mobile/android/base/sqlite/ByteBufferInputStream.java /tmp/mozilla-release/mobile/android/base/sqlite/ByteBufferInputStream.java +--- a/mobile/android/base/sqlite/ByteBufferInputStream.java 2015-02-23 22:40:38.708934982 +0100 ++++ b/mobile/android/base/sqlite/ByteBufferInputStream.java 2015-01-23 07:00:04.000000000 +0100 +@@ -14,7 +14,7 @@ + * easier to use. + */ + public class ByteBufferInputStream extends InputStream { +- private ByteBuffer mByteBuffer; ++ private final ByteBuffer mByteBuffer; + + public ByteBufferInputStream(ByteBuffer aByteBuffer) { + mByteBuffer = aByteBuffer; +diff -ru mobile/android/base/sqlite/MatrixBlobCursor.java /tmp/mozilla-release/mobile/android/base/sqlite/MatrixBlobCursor.java +--- a/mobile/android/base/sqlite/MatrixBlobCursor.java 2015-02-23 22:40:38.720934982 +0100 ++++ b/mobile/android/base/sqlite/MatrixBlobCursor.java 2015-01-23 07:00:04.000000000 +0100 +@@ -17,34 +17,37 @@ + + package org.mozilla.gecko.sqlite; + ++import java.nio.ByteBuffer; ++import java.util.ArrayList; ++ ++import org.mozilla.gecko.AppConstants; + import org.mozilla.gecko.mozglue.generatorannotations.WrapElementForJNI; + + import android.database.AbstractCursor; + import android.database.CursorIndexOutOfBoundsException; ++import android.util.Log; + +-import java.nio.ByteBuffer; +-import java.util.ArrayList; +- +-/* +- * Android's AbstractCursor throws on getBlob() +- * and MatrixCursor forgot to override it. This was fixed +- * at some point but old devices are still SOL. +- * Oh, and everything in MatrixCursor is private instead of +- * protected, so we need to entirely duplicate it here, +- * instad of just being able to add the missing method. +- */ + /** + * A mutable cursor implementation backed by an array of {@code Object}s. Use + * {@link #newRow()} to add rows. Automatically expands internal capacity + * as needed. ++ * ++ * This class provides one missing feature from Android's MatrixCursor: ++ * the implementation of getBlob that was inadvertently omitted from API 9 (and ++ * perhaps later; it's present in 14). ++ * ++ * MatrixCursor is all private, so we entirely duplicate it here. + */ + public class MatrixBlobCursor extends AbstractCursor { ++ private static final String LOGTAG = "GeckoMatrixCursor"; + + private final String[] columnNames; +- private Object[] data; +- private int rowCount = 0; + private final int columnCount; + ++ private int rowCount; ++ ++ Object[] data; ++ + /** + * Constructs a new cursor with the given initial capacity. + * +@@ -140,17 +143,18 @@ + */ + @WrapElementForJNI + public void addRow(Iterable<?> columnValues) { +- int start = rowCount * columnCount; +- int end = start + columnCount; +- ensureCapacity(end); ++ final int start = rowCount * columnCount; + + if (columnValues instanceof ArrayList<?>) { + addRow((ArrayList<?>) columnValues, start); + return; + } + ++ final int end = start + columnCount; + int current = start; +- Object[] localData = data; ++ ++ ensureCapacity(end); ++ final Object[] localData = data; + for (Object columnValue : columnValues) { + if (current == end) { + // TODO: null out row? +@@ -173,39 +177,47 @@ + /** Optimization for {@link ArrayList}. */ + @WrapElementForJNI + private void addRow(ArrayList<?> columnValues, int start) { +- int size = columnValues.size(); ++ final int size = columnValues.size(); + if (size != columnCount) { + throw new IllegalArgumentException("columnNames.length = " + + columnCount + ", columnValues.size() = " + size); + } + +- rowCount++; +- Object[] localData = data; ++ final int end = start + columnCount; ++ ensureCapacity(end); ++ ++ // Take a reference just in case someone calls ensureCapacity ++ // and `data` gets replaced by a new array! ++ final Object[] localData = data; + for (int i = 0; i < size; i++) { + localData[start + i] = columnValues.get(i); + } ++ ++ rowCount++; + } + +- /** Ensures that this cursor has enough capacity. */ +- private void ensureCapacity(int size) { +- if (size > data.length) { +- Object[] oldData = this.data; +- int newSize = data.length * 2; +- if (newSize < size) { +- newSize = size; +- } +- this.data = new Object[newSize]; +- System.arraycopy(oldData, 0, this.data, 0, oldData.length); ++ /** ++ * Ensures that this cursor has enough capacity. If it needs to allocate ++ * a new array, the existing capacity will be at least doubled. ++ */ ++ private void ensureCapacity(final int size) { ++ if (size <= data.length) { ++ return; + } ++ ++ final Object[] oldData = this.data; ++ this.data = new Object[Math.max(size, data.length * 2)]; ++ System.arraycopy(oldData, 0, this.data, 0, oldData.length); + } + + /** + * Builds a row, starting from the left-most column and adding one column + * value at a time. Follows the same ordering as the column names specified + * at cursor construction time. ++ * ++ * Not thread-safe. + */ + public class RowBuilder { +- + private int index; + private final int endIndex; + +@@ -221,10 +233,9 @@ + * values + * @return this builder to support chaining + */ +- public RowBuilder add(Object columnValue) { ++ public RowBuilder add(final Object columnValue) { + if (index == endIndex) { +- throw new CursorIndexOutOfBoundsException( +- "No more columns left."); ++ throw new CursorIndexOutOfBoundsException("No more columns left."); + } + + data[index++] = columnValue; +@@ -232,6 +243,9 @@ + } + } + ++ /** ++ * Not thread safe. ++ */ + public void set(int column, Object value) { + if (column < 0 || column >= columnCount) { + throw new CursorIndexOutOfBoundsException("Requested column: " +@@ -266,7 +280,7 @@ + + @Override + public short getShort(int column) { +- Object value = get(column); ++ final Object value = get(column); + if (value == null) return 0; + if (value instanceof Number) return ((Number) value).shortValue(); + return Short.parseShort(value.toString()); +@@ -311,10 +325,11 @@ + if (value instanceof byte[]) { + return (byte[]) value; + } ++ + if (value instanceof ByteBuffer) { +- ByteBuffer data = (ByteBuffer)value; +- byte[] byteArray = new byte[data.remaining()]; +- data.get(byteArray); ++ final ByteBuffer bytes = (ByteBuffer) value; ++ byte[] byteArray = new byte[bytes.remaining()]; ++ bytes.get(byteArray); + return byteArray; + } + throw new UnsupportedOperationException("BLOB Object not of known type"); +@@ -324,4 +339,15 @@ + public boolean isNull(int column) { + return get(column) == null; + } ++ ++ @Override ++ protected void finalize() { ++ if (AppConstants.DEBUG_BUILD) { ++ if (!isClosed()) { ++ Log.e(LOGTAG, "Cursor finalized without being closed", new RuntimeException("stack")); ++ } ++ } ++ ++ super.finalize(); ++ } + } +diff -ru mobile/android/base/sqlite/SQLiteBridge.java /tmp/mozilla-release/mobile/android/base/sqlite/SQLiteBridge.java +--- a/mobile/android/base/sqlite/SQLiteBridge.java 2015-02-23 22:40:38.716934982 +0100 ++++ b/mobile/android/base/sqlite/SQLiteBridge.java 2015-01-23 07:00:04.000000000 +0100 +@@ -26,16 +26,16 @@ + private static final String LOGTAG = "SQLiteBridge"; + + // Path to the database. If this database was not opened with openDatabase, we reopen it every query. +- private String mDb; ++ private final String mDb; + + // Pointer to the database if it was opened with openDatabase. 0 implies closed. +- protected volatile long mDbPointer = 0L; ++ protected volatile long mDbPointer; + + // Values remembered after a query. + private long[] mQueryResults; + +- private boolean mTransactionSuccess = false; +- private boolean mInTransaction = false; ++ private boolean mTransactionSuccess; ++ private boolean mInTransaction; + + private static final int RESULT_INSERT_ROW_ID = 0; + private static final int RESULT_ROWS_CHANGED = 1; +@@ -227,6 +227,7 @@ + cursor.moveToFirst(); + String version = cursor.getString(0); + ret = Integer.parseInt(version); ++ cursor.close(); + } + return ret; + } diff --git a/data/patches/disable/0003-upgrade-mobile-sync-to-v32.patch b/data/patches/disable/0003-upgrade-mobile-sync-to-v32.patch new file mode 100644 index 0000000..e420727 --- /dev/null +++ b/data/patches/disable/0003-upgrade-mobile-sync-to-v32.patch @@ -0,0 +1,992 @@ +diff -ruN mozilla-esr31/mobile/android/base/fxa/FirefoxAccounts.java mozilla-release/mobile/android/base/fxa/FirefoxAccounts.java +--- mozilla-esr31/mobile/android/base/fxa/FirefoxAccounts.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/FirefoxAccounts.java 2014-09-24 03:05:32.000000000 +0200 +@@ -6,13 +6,18 @@ + + import java.io.File; + import java.util.EnumSet; ++import java.util.Locale; + import java.util.concurrent.CountDownLatch; + ++import org.mozilla.gecko.AppConstants; ++import org.mozilla.gecko.R; + import org.mozilla.gecko.background.common.log.Logger; + import org.mozilla.gecko.fxa.authenticator.AccountPickler; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; ++import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.sync.FxAccountSyncAdapter; + import org.mozilla.gecko.fxa.sync.FxAccountSyncStatusHelper; ++import org.mozilla.gecko.fxa.tasks.FxAccountCodeResender; + import org.mozilla.gecko.sync.ThreadPool; + import org.mozilla.gecko.sync.Utils; + +@@ -20,6 +25,7 @@ + import android.accounts.AccountManager; + import android.content.ContentResolver; + import android.content.Context; ++import android.content.res.Resources; + import android.os.Bundle; + + /** +@@ -152,6 +158,38 @@ + return null; + } + ++ /** ++ * @return ++ * the {@link State} instance associated with the current account, or <code>null</code> if ++ * no accounts exist. ++ */ ++ public static State getFirefoxAccountState(final Context context) { ++ final Account account = getFirefoxAccount(context); ++ if (account == null) { ++ return null; ++ } ++ ++ final AndroidFxAccount fxAccount = new AndroidFxAccount(context, account); ++ try { ++ return fxAccount.getState(); ++ } catch (final Exception ex) { ++ Logger.warn(LOG_TAG, "Could not get FX account state.", ex); ++ return null; ++ } ++ } ++ ++ /* ++ * @param context Android context ++ * @return the email address associated with the configured Firefox account if one exists; null otherwise. ++ */ ++ public static String getFirefoxAccountEmail(final Context context) { ++ final Account account = getFirefoxAccount(context); ++ if (account == null) { ++ return null; ++ } ++ return account.name; ++ } ++ + protected static void putHintsToSync(final Bundle extras, EnumSet<SyncHint> syncHints) { + // stagesToSync and stagesToSkip are allowed to be null. + if (syncHints == null) { +@@ -264,4 +302,33 @@ + // stopObserving null-checks its argument. + FxAccountSyncStatusHelper.getInstance().stopObserving(syncStatusListener); + } ++ ++ public static String getOldSyncUpgradeURL(final Resources res, final Locale locale) { ++ final String VERSION = AppConstants.MOZ_APP_VERSION; ++ final String OS = AppConstants.OS_TARGET; ++ final String LOCALE = Utils.getLanguageTag(locale); ++ return res.getString(R.string.fxaccount_link_old_firefox, VERSION, OS, LOCALE); ++ } ++ ++ /** ++ * Resends the account verification email, and displays an appropriate ++ * toast on both send success and failure. Note that because the underlying implementation ++ * uses {@link AsyncTask}, the provided context must be UI-capable, and this ++ * method called from the UI thread (see ++ * {@link org.mozilla.gecko.fxa.tasks.FxAccountCodeResender#resendCode(Context, AndroidFxAccount)} ++ * for more). ++ * ++ * @param context a UI-capable Android context. ++ * @return true if an account exists, false otherwise. ++ */ ++ public static boolean resendVerificationEmail(final Context context) { ++ final Account account = getFirefoxAccount(context); ++ if (account == null) { ++ return false; ++ } ++ ++ final AndroidFxAccount fxAccount = new AndroidFxAccount(context, account); ++ FxAccountCodeResender.resendCode(context, fxAccount); ++ return true; ++ } + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -19,10 +19,10 @@ + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.background.fxa.QuickPasswordStretcher; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.ProgressDisplay; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; + import org.mozilla.gecko.fxa.login.Engaged; + import org.mozilla.gecko.fxa.login.State; ++import org.mozilla.gecko.fxa.tasks.FxAccountSetupTask.ProgressDisplay; + import org.mozilla.gecko.sync.SyncConfiguration; + import org.mozilla.gecko.sync.setup.Constants; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountConfirmAccountActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -4,21 +4,15 @@ + + package org.mozilla.gecko.fxa.activities; + +-import java.util.concurrent.Executor; +-import java.util.concurrent.Executors; +- + import org.mozilla.gecko.R; + import org.mozilla.gecko.background.common.log.Logger; +-import org.mozilla.gecko.background.fxa.FxAccountClient; +-import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; +-import org.mozilla.gecko.background.fxa.FxAccountClient20; +-import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; + import org.mozilla.gecko.fxa.FirefoxAccounts; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; + import org.mozilla.gecko.fxa.login.Engaged; + import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.login.State.Action; + import org.mozilla.gecko.fxa.sync.FxAccountSyncStatusHelper; ++import org.mozilla.gecko.fxa.tasks.FxAccountCodeResender; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + + import android.accounts.Account; +@@ -28,7 +22,6 @@ + import android.view.View; + import android.view.View.OnClickListener; + import android.widget.TextView; +-import android.widget.Toast; + + /** + * Activity which displays account created successfully screen to the user, and +@@ -164,76 +157,8 @@ + resendLink.setClickable(resendLinkShouldBeEnabled); + } + +- public static class FxAccountResendCodeTask extends FxAccountSetupTask<Void> { +- protected static final String LOG_TAG = FxAccountResendCodeTask.class.getSimpleName(); +- +- protected final byte[] sessionToken; +- +- public FxAccountResendCodeTask(Context context, byte[] sessionToken, FxAccountClient client, RequestDelegate<Void> delegate) { +- super(context, null, client, delegate); +- this.sessionToken = sessionToken; +- } +- +- @Override +- protected InnerRequestDelegate<Void> doInBackground(Void... arg0) { +- try { +- client.resendCode(sessionToken, innerDelegate); +- latch.await(); +- return innerDelegate; +- } catch (Exception e) { +- Logger.error(LOG_TAG, "Got exception signing in.", e); +- delegate.handleError(e); +- } +- return null; +- } +- } +- +- protected static class ResendCodeDelegate implements RequestDelegate<Void> { +- public final Context context; +- +- public ResendCodeDelegate(Context context) { +- this.context = context; +- } +- +- @Override +- public void handleError(Exception e) { +- Logger.warn(LOG_TAG, "Got exception requesting fresh confirmation link; ignoring.", e); +- Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_not_sent, Toast.LENGTH_LONG).show(); +- } +- +- @Override +- public void handleFailure(FxAccountClientRemoteException e) { +- handleError(e); +- } +- +- @Override +- public void handleSuccess(Void result) { +- Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_sent, Toast.LENGTH_SHORT).show(); +- } +- } +- +- public static void resendCode(Context context, AndroidFxAccount fxAccount) { +- RequestDelegate<Void> delegate = new ResendCodeDelegate(context); +- +- byte[] sessionToken; +- try { +- sessionToken = ((Engaged) fxAccount.getState()).getSessionToken(); +- } catch (Exception e) { +- delegate.handleError(e); +- return; +- } +- if (sessionToken == null) { +- delegate.handleError(new IllegalStateException("sessionToken should not be null")); +- return; +- } +- +- Executor executor = Executors.newSingleThreadExecutor(); +- FxAccountClient client = new FxAccountClient20(fxAccount.getAccountServerURI(), executor); +- new FxAccountResendCodeTask(context, sessionToken, client, delegate).execute(); +- } +- + @Override + public void onClick(View v) { +- resendCode(this, fxAccount); ++ FxAccountCodeResender.resendCode(this, fxAccount); + } + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountCreateAccountActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -21,7 +21,7 @@ + import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.FxAccountCreateAccountTask; ++import org.mozilla.gecko.fxa.tasks.FxAccountCreateAccountTask; + + import android.app.AlertDialog; + import android.app.Dialog; +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountGetStartedActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -6,13 +6,11 @@ + + import java.util.Locale; + +-import org.mozilla.gecko.AppConstants; + import org.mozilla.gecko.R; + import org.mozilla.gecko.background.common.log.Logger; + import org.mozilla.gecko.background.fxa.FxAccountAgeLockoutHelper; + import org.mozilla.gecko.fxa.FirefoxAccounts; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.sync.Utils; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + import org.mozilla.gecko.sync.setup.activities.LocaleAware; + +@@ -109,11 +107,7 @@ + protected void linkifyOldFirefoxLink() { + TextView oldFirefox = (TextView) findViewById(R.id.old_firefox); + String text = getResources().getString(R.string.fxaccount_getting_started_old_firefox); +- String VERSION = AppConstants.MOZ_APP_VERSION; +- String OS = AppConstants.OS_TARGET; +- +- String LOCALE = Utils.getLanguageTag(Locale.getDefault()); +- String url = getResources().getString(R.string.fxaccount_link_old_firefox, VERSION, OS, LOCALE); ++ final String url = FirefoxAccounts.getOldSyncUpgradeURL(getResources(), Locale.getDefault()); + FxAccountConstants.pii(LOG_TAG, "Old Firefox url is: " + url); // Don't want to leak locale in particular. + ActivityUtils.linkTextView(oldFirefox, text, url); + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSetupTask.java mozilla-release/mobile/android/base/fxa/activities/FxAccountSetupTask.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSetupTask.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountSetupTask.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,172 +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/. */ +- +-package org.mozilla.gecko.fxa.activities; +- +-import java.io.UnsupportedEncodingException; +-import java.util.concurrent.CountDownLatch; +- +-import org.mozilla.gecko.background.common.log.Logger; +-import org.mozilla.gecko.background.fxa.FxAccountClient; +-import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; +-import org.mozilla.gecko.background.fxa.FxAccountClient20.LoginResponse; +-import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; +-import org.mozilla.gecko.background.fxa.PasswordStretcher; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.InnerRequestDelegate; +- +-import android.content.Context; +-import android.os.AsyncTask; +- +-/** +- * An <code>AsyncTask</code> wrapper around signing up for, and signing in to, a +- * Firefox Account. +- * <p> +- * It's strange to add explicit blocking to callback-threading code, but we do +- * it here to take advantage of Android's built in support for background work. +- * We really want to avoid making a threading mistake that brings down the whole +- * process. +- */ +-abstract class FxAccountSetupTask<T> extends AsyncTask<Void, Void, InnerRequestDelegate<T>> { +- private static final String LOG_TAG = FxAccountSetupTask.class.getSimpleName(); +- +- public interface ProgressDisplay { +- public void showProgress(); +- public void dismissProgress(); +- } +- +- protected final Context context; +- protected final FxAccountClient client; +- protected final ProgressDisplay progressDisplay; +- +- // Initialized lazily. +- protected byte[] quickStretchedPW; +- +- // AsyncTask's are one-time-use, so final members are fine. +- protected final CountDownLatch latch = new CountDownLatch(1); +- protected final InnerRequestDelegate<T> innerDelegate = new InnerRequestDelegate<T>(latch); +- +- protected final RequestDelegate<T> delegate; +- +- public FxAccountSetupTask(Context context, ProgressDisplay progressDisplay, FxAccountClient client, RequestDelegate<T> delegate) { +- this.context = context; +- this.client = client; +- this.delegate = delegate; +- this.progressDisplay = progressDisplay; +- } +- +- @Override +- protected void onPreExecute() { +- if (progressDisplay != null) { +- progressDisplay.showProgress(); +- } +- } +- +- @Override +- protected void onPostExecute(InnerRequestDelegate<T> result) { +- if (progressDisplay != null) { +- progressDisplay.dismissProgress(); +- } +- +- // We are on the UI thread, and need to invoke these callbacks here to allow UI updating. +- if (innerDelegate.failure != null) { +- delegate.handleFailure(innerDelegate.failure); +- } else if (innerDelegate.exception != null) { +- delegate.handleError(innerDelegate.exception); +- } else { +- delegate.handleSuccess(result.response); +- } +- } +- +- @Override +- protected void onCancelled(InnerRequestDelegate<T> result) { +- if (progressDisplay != null) { +- progressDisplay.dismissProgress(); +- } +- delegate.handleError(new IllegalStateException("Task was cancelled.")); +- } +- +- protected static class InnerRequestDelegate<T> implements RequestDelegate<T> { +- protected final CountDownLatch latch; +- public T response = null; +- public Exception exception = null; +- public FxAccountClientRemoteException failure = null; +- +- protected InnerRequestDelegate(CountDownLatch latch) { +- this.latch = latch; +- } +- +- @Override +- public void handleError(Exception e) { +- Logger.error(LOG_TAG, "Got exception."); +- this.exception = e; +- latch.countDown(); +- } +- +- @Override +- public void handleFailure(FxAccountClientRemoteException e) { +- Logger.warn(LOG_TAG, "Got failure."); +- this.failure = e; +- latch.countDown(); +- } +- +- @Override +- public void handleSuccess(T result) { +- Logger.info(LOG_TAG, "Got success."); +- this.response = result; +- latch.countDown(); +- } +- } +- +- public static class FxAccountCreateAccountTask extends FxAccountSetupTask<LoginResponse> { +- private static final String LOG_TAG = FxAccountCreateAccountTask.class.getSimpleName(); +- +- protected final byte[] emailUTF8; +- protected final PasswordStretcher passwordStretcher; +- +- public FxAccountCreateAccountTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { +- super(context, progressDisplay, client, delegate); +- this.emailUTF8 = email.getBytes("UTF-8"); +- this.passwordStretcher = passwordStretcher; +- } +- +- @Override +- protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { +- try { +- client.createAccountAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); +- latch.await(); +- return innerDelegate; +- } catch (Exception e) { +- Logger.error(LOG_TAG, "Got exception logging in.", e); +- delegate.handleError(e); +- } +- return null; +- } +- } +- +- public static class FxAccountSignInTask extends FxAccountSetupTask<LoginResponse> { +- protected static final String LOG_TAG = FxAccountSignInTask.class.getSimpleName(); +- +- protected final byte[] emailUTF8; +- protected final PasswordStretcher passwordStretcher; +- +- public FxAccountSignInTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { +- super(context, progressDisplay, client, delegate); +- this.emailUTF8 = email.getBytes("UTF-8"); +- this.passwordStretcher = passwordStretcher; +- } +- +- @Override +- protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { +- try { +- client.loginAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); +- latch.await(); +- return innerDelegate; +- } catch (Exception e) { +- Logger.error(LOG_TAG, "Got exception signing in.", e); +- delegate.handleError(e); +- } +- return null; +- } +- } +-} +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSignInActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountSignInActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountSignInActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountSignInActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -16,7 +16,7 @@ + import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.FxAccountSignInTask; ++import org.mozilla.gecko.fxa.tasks.FxAccountSignInTask; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + + import android.content.Intent; +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountStatusFragment.java mozilla-release/mobile/android/base/fxa/activities/FxAccountStatusFragment.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountStatusFragment.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountStatusFragment.java 2014-09-24 03:05:32.000000000 +0200 +@@ -17,6 +17,8 @@ + import org.mozilla.gecko.fxa.login.Married; + import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.sync.FxAccountSyncStatusHelper; ++import org.mozilla.gecko.fxa.tasks.FxAccountCodeResender; ++import org.mozilla.gecko.sync.SharedPreferencesClientsDataDelegate; + import org.mozilla.gecko.sync.SyncConfiguration; + + import android.accounts.Account; +@@ -27,10 +29,13 @@ + import android.os.Bundle; + import android.os.Handler; + import android.preference.CheckBoxPreference; ++import android.preference.EditTextPreference; + import android.preference.Preference; ++import android.preference.Preference.OnPreferenceChangeListener; + import android.preference.Preference.OnPreferenceClickListener; + import android.preference.PreferenceCategory; + import android.preference.PreferenceScreen; ++import android.text.TextUtils; + + /** + * A fragment that displays the status of an AndroidFxAccount. +@@ -38,7 +43,9 @@ + * The owning activity is responsible for providing an AndroidFxAccount at + * appropriate times. + */ +-public class FxAccountStatusFragment extends PreferenceFragment implements OnPreferenceClickListener { ++public class FxAccountStatusFragment ++ extends PreferenceFragment ++ implements OnPreferenceClickListener, OnPreferenceChangeListener { + private static final String LOG_TAG = FxAccountStatusFragment.class.getSimpleName(); + + // When a checkbox is toggled, wait 5 seconds (for other checkbox actions) +@@ -64,7 +71,12 @@ + protected CheckBoxPreference tabsPreference; + protected CheckBoxPreference passwordsPreference; + ++ protected EditTextPreference deviceNamePreference; ++ + protected volatile AndroidFxAccount fxAccount; ++ // The contract is: when fxAccount is non-null, then clientsDataDelegate is ++ // non-null. If violated then an IllegalStateException is thrown. ++ protected volatile SharedPreferencesClientsDataDelegate clientsDataDelegate; + + // Used to post delayed sync requests. + protected Handler handler; +@@ -87,6 +99,10 @@ + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); ++ addPreferences(); ++ } ++ ++ protected void addPreferences() { + addPreferencesFromResource(R.xml.fxaccount_status_prefscreen); + + emailPreference = ensureFindPreference("email"); +@@ -118,6 +134,9 @@ + historyPreference.setOnPreferenceClickListener(this); + tabsPreference.setOnPreferenceClickListener(this); + passwordsPreference.setOnPreferenceClickListener(this); ++ ++ deviceNamePreference = (EditTextPreference) ensureFindPreference("device_name"); ++ deviceNamePreference.setOnPreferenceChangeListener(this); + } + + /** +@@ -142,7 +161,7 @@ + } + + if (preference == needsVerificationPreference) { +- FxAccountConfirmAccountActivity.resendCode(getActivity().getApplicationContext(), fxAccount); ++ FxAccountCodeResender.resendCode(getActivity().getApplicationContext(), fxAccount); + + Intent intent = new Intent(getActivity(), FxAccountConfirmAccountActivity.class); + // Per http://stackoverflow.com/a/8992365, this triggers a known bug with +@@ -176,6 +195,8 @@ + historyPreference.setEnabled(enabled); + tabsPreference.setEnabled(enabled); + passwordsPreference.setEnabled(enabled); ++ // Since we can't sync, we can't update our remote client record. ++ deviceNamePreference.setEnabled(enabled); + } + + /** +@@ -293,6 +314,14 @@ + throw new IllegalArgumentException("fxAccount must not be null"); + } + this.fxAccount = fxAccount; ++ try { ++ this.clientsDataDelegate = new SharedPreferencesClientsDataDelegate(fxAccount.getSyncPrefs()); ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception fetching Sync prefs associated to Firefox Account; aborting.", e); ++ // Something is terribly wrong; best to get a stack trace rather than ++ // continue with a null clients delegate. ++ throw new IllegalStateException(e); ++ } + + handler = new Handler(); // Attached to current (assumed to be UI) thread. + +@@ -318,6 +347,17 @@ + FxAccountSyncStatusHelper.getInstance().stopObserving(syncStatusDelegate); + } + ++ protected void hardRefresh() { ++ // This is the only way to guarantee that the EditText dialogs created by ++ // EditTextPreferences are re-created. This works around the issue described ++ // at http://androiddev.orkitra.com/?p=112079. ++ final PreferenceScreen statusScreen = (PreferenceScreen) ensureFindPreference("status_screen"); ++ statusScreen.removeAll(); ++ addPreferences(); ++ ++ refresh(); ++ } ++ + protected void refresh() { + // refresh is called from our onResume, which can happen before the owning + // Activity tells us about an account (via our public +@@ -371,6 +411,10 @@ + // No matter our state, we should update the checkboxes. + updateSelectedEngines(); + } ++ ++ final String clientName = clientsDataDelegate.getClientName(); ++ deviceNamePreference.setSummary(clientName); ++ deviceNamePreference.setText(clientName); + } + + /** +@@ -570,4 +614,22 @@ + button.setOnPreferenceClickListener(listener); + } + } ++ ++ @Override ++ public boolean onPreferenceChange(Preference preference, Object newValue) { ++ if (preference == deviceNamePreference) { ++ String newClientName = (String) newValue; ++ if (TextUtils.isEmpty(newClientName)) { ++ newClientName = clientsDataDelegate.getDefaultClientName(); ++ } ++ final long now = System.currentTimeMillis(); ++ clientsDataDelegate.setClientName(newClientName, now); ++ requestDelayedSync(); // Try to update our remote client record. ++ hardRefresh(); // Updates the value displayed to the user, among other things. ++ return true; ++ } ++ ++ // For everything else, accept the change. ++ return true; ++ } + } +diff -ruN mozilla-esr31/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java mozilla-release/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java +--- mozilla-esr31/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/activities/FxAccountUpdateCredentialsActivity.java 2014-09-24 03:05:32.000000000 +0200 +@@ -18,11 +18,11 @@ + import org.mozilla.gecko.background.fxa.PasswordStretcher; + import org.mozilla.gecko.fxa.FirefoxAccounts; + import org.mozilla.gecko.fxa.FxAccountConstants; +-import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.FxAccountSignInTask; + import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; + import org.mozilla.gecko.fxa.login.Engaged; + import org.mozilla.gecko.fxa.login.State; + import org.mozilla.gecko.fxa.login.State.StateLabel; ++import org.mozilla.gecko.fxa.tasks.FxAccountSignInTask; + import org.mozilla.gecko.sync.setup.activities.ActivityUtils; + + import android.os.Bundle; +diff -ruN mozilla-esr31/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java mozilla-release/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java +--- mozilla-esr31/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java 2015-02-25 19:21:06.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/sync/FxAccountSyncAdapter.java 2014-09-24 03:05:33.000000000 +0200 +@@ -357,7 +357,11 @@ + + FxAccountGlobalSession globalSession = null; + try { +- ClientsDataDelegate clientsDataDelegate = new SharedPreferencesClientsDataDelegate(sharedPrefs); ++ final ClientsDataDelegate clientsDataDelegate = new SharedPreferencesClientsDataDelegate(sharedPrefs); ++ if (FxAccountConstants.LOG_PERSONAL_INFORMATION) { ++ FxAccountConstants.pii(LOG_TAG, "Client device name is: '" + clientsDataDelegate.getClientName() + "'."); ++ FxAccountConstants.pii(LOG_TAG, "Client device data last modified: " + clientsDataDelegate.getLastModifiedTimestamp()); ++ } + + // We compute skew over time using SkewHandler. This yields an unchanging + // skew adjustment that the HawkAuthHeaderProvider uses to adjust its +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCodeResender.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountCodeResender.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCodeResender.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountCodeResender.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,108 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.util.concurrent.Executor; ++import java.util.concurrent.Executors; ++ ++import org.mozilla.gecko.R; ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClient20; ++import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; ++import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount; ++import org.mozilla.gecko.fxa.login.Engaged; ++ ++import android.content.Context; ++import android.widget.Toast; ++ ++/** ++ * A helper class that provides a simple interface for requesting ++ * a Firefox Account verification email to be resent. ++ */ ++public class FxAccountCodeResender { ++ private static final String LOG_TAG = FxAccountCodeResender.class.getSimpleName(); ++ ++ private static class FxAccountResendCodeTask extends FxAccountSetupTask<Void> { ++ protected static final String LOG_TAG = FxAccountResendCodeTask.class.getSimpleName(); ++ ++ protected final byte[] sessionToken; ++ ++ public FxAccountResendCodeTask(Context context, byte[] sessionToken, FxAccountClient client, RequestDelegate<Void> delegate) { ++ super(context, null, client, delegate); ++ this.sessionToken = sessionToken; ++ } ++ ++ @Override ++ protected InnerRequestDelegate<Void> doInBackground(Void... arg0) { ++ try { ++ client.resendCode(sessionToken, innerDelegate); ++ latch.await(); ++ return innerDelegate; ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception signing in.", e); ++ delegate.handleError(e); ++ } ++ return null; ++ } ++ } ++ ++ private static class ResendCodeDelegate implements RequestDelegate<Void> { ++ public final Context context; ++ ++ public ResendCodeDelegate(Context context) { ++ this.context = context; ++ } ++ ++ @Override ++ public void handleError(Exception e) { ++ Logger.warn(LOG_TAG, "Got exception requesting fresh confirmation link; ignoring.", e); ++ Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_not_sent, Toast.LENGTH_LONG).show(); ++ } ++ ++ @Override ++ public void handleFailure(FxAccountClientRemoteException e) { ++ handleError(e); ++ } ++ ++ @Override ++ public void handleSuccess(Void result) { ++ Toast.makeText(context, R.string.fxaccount_confirm_account_verification_link_sent, Toast.LENGTH_SHORT).show(); ++ } ++ } ++ ++ /** ++ * Resends the account verification email, and displays an appropriate ++ * toast on both send success and failure. Note that because the underlying implementation ++ * uses {@link AsyncTask}, the provided context must be UI-capable and ++ * this method called from the UI thread. ++ * ++ * Note that it may actually be possible to run this (and the {@link AsyncTask}) method ++ * from a background thread - but this hasn't been tested. ++ * ++ * @param context A UI-capable Android context. ++ * @param fxAccount The Firefox Account to resend the code to. ++ */ ++ public static void resendCode(Context context, AndroidFxAccount fxAccount) { ++ RequestDelegate<Void> delegate = new ResendCodeDelegate(context); ++ ++ byte[] sessionToken; ++ try { ++ sessionToken = ((Engaged) fxAccount.getState()).getSessionToken(); ++ } catch (Exception e) { ++ delegate.handleError(e); ++ return; ++ } ++ if (sessionToken == null) { ++ delegate.handleError(new IllegalStateException("sessionToken should not be null")); ++ return; ++ } ++ ++ Executor executor = Executors.newSingleThreadExecutor(); ++ FxAccountClient client = new FxAccountClient20(fxAccount.getAccountServerURI(), executor); ++ new FxAccountResendCodeTask(context, sessionToken, client, delegate).execute(); ++ } ++} +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountCreateAccountTask.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,41 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.io.UnsupportedEncodingException; ++ ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClient20.LoginResponse; ++import org.mozilla.gecko.background.fxa.PasswordStretcher; ++ ++import android.content.Context; ++ ++public class FxAccountCreateAccountTask extends FxAccountSetupTask<LoginResponse> { ++ private static final String LOG_TAG = FxAccountCreateAccountTask.class.getSimpleName(); ++ ++ protected final byte[] emailUTF8; ++ protected final PasswordStretcher passwordStretcher; ++ ++ public FxAccountCreateAccountTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { ++ super(context, progressDisplay, client, delegate); ++ this.emailUTF8 = email.getBytes("UTF-8"); ++ this.passwordStretcher = passwordStretcher; ++ } ++ ++ @Override ++ protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { ++ try { ++ client.createAccountAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); ++ latch.await(); ++ return innerDelegate; ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception logging in.", e); ++ delegate.handleError(e); ++ } ++ return null; ++ } ++} +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSetupTask.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountSetupTask.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSetupTask.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountSetupTask.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,117 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.util.concurrent.CountDownLatch; ++ ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException; ++import org.mozilla.gecko.fxa.tasks.FxAccountSetupTask.InnerRequestDelegate; ++ ++import android.content.Context; ++import android.os.AsyncTask; ++ ++/** ++ * An <code>AsyncTask</code> wrapper around signing up for, and signing in to, a ++ * Firefox Account. ++ * <p> ++ * It's strange to add explicit blocking to callback-threading code, but we do ++ * it here to take advantage of Android's built in support for background work. ++ * We really want to avoid making a threading mistake that brings down the whole ++ * process. ++ */ ++public abstract class FxAccountSetupTask<T> extends AsyncTask<Void, Void, InnerRequestDelegate<T>> { ++ private static final String LOG_TAG = FxAccountSetupTask.class.getSimpleName(); ++ ++ public interface ProgressDisplay { ++ public void showProgress(); ++ public void dismissProgress(); ++ } ++ ++ protected final Context context; ++ protected final FxAccountClient client; ++ protected final ProgressDisplay progressDisplay; ++ ++ // Initialized lazily. ++ protected byte[] quickStretchedPW; ++ ++ // AsyncTask's are one-time-use, so final members are fine. ++ protected final CountDownLatch latch = new CountDownLatch(1); ++ protected final InnerRequestDelegate<T> innerDelegate = new InnerRequestDelegate<T>(latch); ++ ++ protected final RequestDelegate<T> delegate; ++ ++ public FxAccountSetupTask(Context context, ProgressDisplay progressDisplay, FxAccountClient client, RequestDelegate<T> delegate) { ++ this.context = context; ++ this.client = client; ++ this.delegate = delegate; ++ this.progressDisplay = progressDisplay; ++ } ++ ++ @Override ++ protected void onPreExecute() { ++ if (progressDisplay != null) { ++ progressDisplay.showProgress(); ++ } ++ } ++ ++ @Override ++ protected void onPostExecute(InnerRequestDelegate<T> result) { ++ if (progressDisplay != null) { ++ progressDisplay.dismissProgress(); ++ } ++ ++ // We are on the UI thread, and need to invoke these callbacks here to allow UI updating. ++ if (innerDelegate.failure != null) { ++ delegate.handleFailure(innerDelegate.failure); ++ } else if (innerDelegate.exception != null) { ++ delegate.handleError(innerDelegate.exception); ++ } else { ++ delegate.handleSuccess(result.response); ++ } ++ } ++ ++ @Override ++ protected void onCancelled(InnerRequestDelegate<T> result) { ++ if (progressDisplay != null) { ++ progressDisplay.dismissProgress(); ++ } ++ delegate.handleError(new IllegalStateException("Task was cancelled.")); ++ } ++ ++ protected static class InnerRequestDelegate<T> implements RequestDelegate<T> { ++ protected final CountDownLatch latch; ++ public T response = null; ++ public Exception exception = null; ++ public FxAccountClientRemoteException failure = null; ++ ++ protected InnerRequestDelegate(CountDownLatch latch) { ++ this.latch = latch; ++ } ++ ++ @Override ++ public void handleError(Exception e) { ++ Logger.error(LOG_TAG, "Got exception."); ++ this.exception = e; ++ latch.countDown(); ++ } ++ ++ @Override ++ public void handleFailure(FxAccountClientRemoteException e) { ++ Logger.warn(LOG_TAG, "Got failure."); ++ this.failure = e; ++ latch.countDown(); ++ } ++ ++ @Override ++ public void handleSuccess(T result) { ++ Logger.info(LOG_TAG, "Got success."); ++ this.response = result; ++ latch.countDown(); ++ } ++ } ++} +diff -ruN mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSignInTask.java mozilla-release/mobile/android/base/fxa/tasks/FxAccountSignInTask.java +--- mozilla-esr31/mobile/android/base/fxa/tasks/FxAccountSignInTask.java 1970-01-01 01:00:00.000000000 +0100 ++++ mozilla-release/mobile/android/base/fxa/tasks/FxAccountSignInTask.java 2014-09-24 03:05:33.000000000 +0200 +@@ -0,0 +1,41 @@ ++/* 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/. */ ++ ++package org.mozilla.gecko.fxa.tasks; ++ ++import java.io.UnsupportedEncodingException; ++ ++import org.mozilla.gecko.background.common.log.Logger; ++import org.mozilla.gecko.background.fxa.FxAccountClient; ++import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate; ++import org.mozilla.gecko.background.fxa.FxAccountClient20.LoginResponse; ++import org.mozilla.gecko.background.fxa.PasswordStretcher; ++ ++import android.content.Context; ++ ++public class FxAccountSignInTask extends FxAccountSetupTask<LoginResponse> { ++ protected static final String LOG_TAG = FxAccountSignInTask.class.getSimpleName(); ++ ++ protected final byte[] emailUTF8; ++ protected final PasswordStretcher passwordStretcher; ++ ++ public FxAccountSignInTask(Context context, ProgressDisplay progressDisplay, String email, PasswordStretcher passwordStretcher, FxAccountClient client, RequestDelegate<LoginResponse> delegate) throws UnsupportedEncodingException { ++ super(context, progressDisplay, client, delegate); ++ this.emailUTF8 = email.getBytes("UTF-8"); ++ this.passwordStretcher = passwordStretcher; ++ } ++ ++ @Override ++ protected InnerRequestDelegate<LoginResponse> doInBackground(Void... arg0) { ++ try { ++ client.loginAndGetKeys(emailUTF8, passwordStretcher, innerDelegate); ++ latch.await(); ++ return innerDelegate; ++ } catch (Exception e) { ++ Logger.error(LOG_TAG, "Got exception signing in.", e); ++ delegate.handleError(e); ++ } ++ return null; ++ } ++} +--- mozilla-esr31/mobile/android/base/android-services.mozbuild 2015-02-25 19:21:05.000000000 +0100 ++++ mozilla-release/mobile/android/base/android-services.mozbuild 2014-09-24 03:05:32.000000000 +0200 +@@ -555,7 +557,6 @@ + 'fxa/activities/FxAccountCreateAccountActivity.java', + 'fxa/activities/FxAccountCreateAccountNotAllowedActivity.java', + 'fxa/activities/FxAccountGetStartedActivity.java', +- 'fxa/activities/FxAccountSetupTask.java', + 'fxa/activities/FxAccountSignInActivity.java', + 'fxa/activities/FxAccountStatusActivity.java', + 'fxa/activities/FxAccountStatusFragment.java', +@@ -589,6 +590,10 @@ + 'fxa/sync/FxAccountSyncService.java', + 'fxa/sync/FxAccountSyncStatusHelper.java', + 'fxa/sync/SchedulePolicy.java', ++ 'fxa/tasks/FxAccountCodeResender.java', ++ 'fxa/tasks/FxAccountCreateAccountTask.java', ++ 'fxa/tasks/FxAccountSetupTask.java', ++ 'fxa/tasks/FxAccountSignInTask.java', + 'sync/AlreadySyncingException.java', + 'sync/BackoffHandler.java', + 'sync/BadRequiredFieldJSONException.java', diff --git a/data/patches/gnuzilla-bug-1010972.patch b/data/patches/gnuzilla-bug-1010972.patch new file mode 100644 index 0000000..94eaf2b --- /dev/null +++ b/data/patches/gnuzilla-bug-1010972.patch @@ -0,0 +1,11 @@ +--- a/media/libyuv/source/cpu_id.cc 2015-01-27 19:15:52.069520584 +0100 ++++ b/media/libyuv/source/cpu_id.cc 2015-01-30 00:50:10.425853894 +0100 +@@ -97,7 +97,7 @@ + uint32 xcr0 = 0u; + #if defined(_MSC_VER) && defined(_XCR_XFEATURE_ENABLED_MASK) + xcr0 = (uint32)(_xgetbv(_XCR_XFEATURE_ENABLED_MASK)); +-#elif defined(_M_IX86) ++#elif defined(_MSC_VER) && defined(_M_IX86) + __asm { + xor ecx, ecx // xcr 0 + _asm _emit 0x0f _asm _emit 0x01 _asm _emit 0xd0 // For VS2010 and earlier. diff --git a/data/patches/gnuzilla-bug-1025689.patch b/data/patches/gnuzilla-bug-1025689.patch new file mode 100644 index 0000000..9364624 --- /dev/null +++ b/data/patches/gnuzilla-bug-1025689.patch @@ -0,0 +1,19 @@ +diff -ru mozilla-esr31/media/libopus/moz.build icecat-31.4.0/media/libopus/moz.build +--- a/media/libopus/moz.build 2015-01-06 06:08:03.000000000 +0100 ++++ b/media/libopus/moz.build 2015-02-02 02:37:44.416803188 +0100 +@@ -23,10 +23,11 @@ + DEFINES['OPUS_ARM_ASM'] = True + DEFINES['OPUS_ARM_EXTERNAL_ASM'] = True + DEFINES['OPUS_ARM_INLINE_ASM'] = True +- DEFINES['OPUS_ARM_INLINE_EDSP'] = True +- DEFINES['OPUS_ARM_MAY_HAVE_EDSP'] = True +- DEFINES['OPUS_ARM_MAY_HAVE_MEDIA'] = True +- DEFINES['OPUS_ARM_MAY_HAVE_NEON'] = True ++ if int(CONFIG['ARM_ARCH']) >= 6: ++ DEFINES['OPUS_ARM_INLINE_EDSP'] = True ++ DEFINES['OPUS_ARM_MAY_HAVE_EDSP'] = True ++ DEFINES['OPUS_ARM_MAY_HAVE_MEDIA'] = True ++ DEFINES['OPUS_ARM_MAY_HAVE_NEON'] = True + + if CONFIG['MOZ_DEBUG']: + DEFINES['ENABLE_ASSERTIONS'] = True diff --git a/data/patches/gnuzilla-bug-1030899-1.patch b/data/patches/gnuzilla-bug-1030899-1.patch new file mode 100644 index 0000000..5f3d3ba --- /dev/null +++ b/data/patches/gnuzilla-bug-1030899-1.patch @@ -0,0 +1,60 @@ +--- a/ipc/chromium/src/third_party/libevent-dont-use-issetugid-on-android.patch ++++ a/ipc/chromium/src/third_party/libevent-dont-use-issetugid-on-android.patch +@@ -0,0 +1,22 @@ ++diff --git a/ipc/chromium/src/third_party/libevent/android/event2/event-config.h b/ipc/chromium/src/third_party/libevent/android/event2/event-config.h ++--- a/ipc/chromium/src/third_party/libevent/android/event2/event-config.h +++++ b/ipc/chromium/src/third_party/libevent/android/event2/event-config.h ++@@ -119,17 +119,17 @@ ++ ++ /* Define to 1 if you have the `inet_pton' function. */ ++ #define _EVENT_HAVE_INET_PTON 1 ++ ++ /* Define to 1 if you have the <inttypes.h> header file. */ ++ #define _EVENT_HAVE_INTTYPES_H 1 ++ ++ /* Define to 1 if you have the `issetugid' function. */ ++-#define _EVENT_HAVE_ISSETUGID 1 +++/* #undef _EVENT_HAVE_ISSETUGID */ ++ ++ /* Define to 1 if you have the `kqueue' function. */ ++ /* #undef _EVENT_HAVE_KQUEUE */ ++ ++ /* Define if the system has zlib */ ++ #define _EVENT_HAVE_LIBZ 1 ++ ++ /* Define to 1 if you have the <memory.h> header file. */ +--- a/ipc/chromium/src/third_party/libevent/README.mozilla ++++ a/ipc/chromium/src/third_party/libevent/README.mozilla +@@ -10,8 +10,10 @@ These files are taken from libevent-2.0. + + 2. This is ugly, prepare yourself. OS X has a weird problem with how the "TAILQ_END(head)" is used, causing a linking error. Just replace all use of the "TAILQ_END(head)" macro with "NULL". + + 3. Apply "add mac-arc4random-buf.patch", which removes some bad OS X compatibility code. This will allow libevent to compile on all supported versions of OS X. + + 4. Apply "openbsd-no-arc4random_addrandom.patch", which fixes the build on OpenBSD (which doesnt provide arc4random_addrandom anymore, see #931354) + + 5. Apply "libevent-use-non-deprecated-syscalls.patch", which fixes the build on AArch64 architecture (which does not provide deprecated syscalls) ++ ++6. Apply "libevent-dont-use-issetugid-on-android.patch'. which fixes the build on Android L preview +--- a/ipc/chromium/src/third_party/libevent/android/event2/event-config.h ++++ a/ipc/chromium/src/third_party/libevent/android/event2/event-config.h +@@ -119,17 +119,17 @@ + + /* Define to 1 if you have the `inet_pton' function. */ + #define _EVENT_HAVE_INET_PTON 1 + + /* Define to 1 if you have the <inttypes.h> header file. */ + #define _EVENT_HAVE_INTTYPES_H 1 + + /* Define to 1 if you have the `issetugid' function. */ +-#define _EVENT_HAVE_ISSETUGID 1 ++/* #undef _EVENT_HAVE_ISSETUGID */ + + /* Define to 1 if you have the `kqueue' function. */ + /* #undef _EVENT_HAVE_KQUEUE */ + + /* Define if the system has zlib */ + #define _EVENT_HAVE_LIBZ 1 + + /* Define to 1 if you have the <memory.h> header file. */ + diff --git a/data/patches/gnuzilla-bug-1030899-2.patch b/data/patches/gnuzilla-bug-1030899-2.patch new file mode 100644 index 0000000..55728ab --- /dev/null +++ b/data/patches/gnuzilla-bug-1030899-2.patch @@ -0,0 +1,59 @@ +--- a/memory/mozjemalloc/jemalloc.c ++++ a/memory/mozjemalloc/jemalloc.c +@@ -220,17 +220,16 @@ + + #ifdef MALLOC_PAGEFILE + /* Write size when initializing a page file. */ + # define MALLOC_PAGEFILE_WRITE_SIZE 512 + #endif + + #if defined(MOZ_MEMORY_LINUX) && !defined(MOZ_MEMORY_ANDROID) + #define _GNU_SOURCE /* For mremap(2). */ +-#define issetugid() 0 + #if 0 /* Enable in order to test decommit code on Linux. */ + # define MALLOC_DECOMMIT + #endif + #endif + + #include <sys/types.h> + + #include <errno.h> +@@ -261,17 +260,16 @@ + #define vsnprintf _vsnprintf + + #ifndef NO_TLS + static unsigned long tlsIndex = 0xffffffff; + #endif + + #define __thread + #define _pthread_self() __threadid() +-#define issetugid() 0 + + /* use MSVC intrinsics */ + #pragma intrinsic(_BitScanForward) + static __forceinline int + ffs(int x) + { + unsigned long i; + +@@ -5675,18 +5673,17 @@ malloc_init_hard(void) + #endif + { + /* No configuration specified. */ + buf[0] = '\0'; + opts = buf; + } + break; + case 1: +- if (issetugid() == 0 && (opts = +- getenv("MALLOC_OPTIONS")) != NULL) { ++ if ((opts = getenv("MALLOC_OPTIONS")) != NULL) { + /* + * Do nothing; opts is already initialized to + * the value of the MALLOC_OPTIONS environment + * variable. + */ + } else { + /* No configuration specified. */ + buf[0] = '\0'; + diff --git a/data/patches/gnuzilla-bug-1032460.patch b/data/patches/gnuzilla-bug-1032460.patch new file mode 100644 index 0000000..08f37c3 --- /dev/null +++ b/data/patches/gnuzilla-bug-1032460.patch @@ -0,0 +1,16 @@ +https://bugzilla.mozilla.org/show_bug.cgi?id=1032460 + +diff -ru icecat-31.4.0.orig/widget/android/AndroidBridge.cpp icecat-31.4.0/widget/android/AndroidBridge.cpp +--- icecat-31.4.0.orig/widget/android/AndroidBridge.cpp 2015-02-22 19:11:11.834816575 +0100 ++++ icecat-31.4.0/widget/android/AndroidBridge.cpp 2015-02-22 19:16:16.226810788 +0100 +@@ -199,7 +199,9 @@ + + jclass eglClass = getClassGlobalRef("com/google/android/gles_jni/EGLSurfaceImpl"); + if (eglClass) { +- jEGLSurfacePointerField = getField("mEGLSurface", "I"); ++ // The pointer type moved to a 'long' in Android L, API version 20 ++ const char* jniType = mAPIVersion >= 20 ? "J" : "I"; ++ jEGLSurfacePointerField = getField("mEGLSurface", jniType); + } else { + jEGLSurfacePointerField = 0; + } diff --git a/data/patches/gnuzilla-bug-1034167-1.patch b/data/patches/gnuzilla-bug-1034167-1.patch new file mode 100644 index 0000000..410b2cf --- /dev/null +++ b/data/patches/gnuzilla-bug-1034167-1.patch @@ -0,0 +1,93 @@ +# HG changeset patch +# User Lucas Rocha <lucasr@mozilla.com> + +Bug 1034167 - Part 2: Explicit set scrollbars in TabsTray (r=mfinkle) + +diff --git a/mobile/android/base/resources/values-land/styles.xml b/mobile/android/base/resources/values-land/styles.xml +index 774c48e..6769b1e 100644 +--- a/mobile/android/base/resources/values-land/styles.xml ++++ b/mobile/android/base/resources/values-land/styles.xml +@@ -2,16 +2,17 @@ + <!-- 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/. --> + + <resources> + + <style name="TabsList" parent="TabsListBase"> + <item name="android:orientation">horizontal</item> ++ <item name="android:scrollbars">horizontal</item> + </style> + + <style name="TabsItem"> + <item name="android:nextFocusDown">@+id/close</item> + </style> + + <style name="TabsItemClose"> + <item name="android:nextFocusUp">@+id/info</item> +diff --git a/mobile/android/base/resources/values-large-land-v11/styles.xml b/mobile/android/base/resources/values-large-land-v11/styles.xml +index 557b659..1468914 100644 +--- a/mobile/android/base/resources/values-large-land-v11/styles.xml ++++ b/mobile/android/base/resources/values-large-land-v11/styles.xml +@@ -2,16 +2,17 @@ + <!-- 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/. --> + + <resources> + + <style name="TabsList" parent="TabsListBase"> + <item name="android:orientation">vertical</item> ++ <item name="android:scrollbars">vertical</item> + </style> + + <style name="Widget.BookmarkFolderView" parent="Widget.TwoLinePageRow.Title"> + <item name="android:paddingLeft">60dip</item> + <item name="android:drawablePadding">10dip</item> + <item name="android:drawableLeft">@drawable/bookmark_folder</item> + </style> + +diff --git a/mobile/android/base/resources/values-large-v11/styles.xml b/mobile/android/base/resources/values-large-v11/styles.xml +index 7a22789..a6a6221 100644 +--- a/mobile/android/base/resources/values-large-v11/styles.xml ++++ b/mobile/android/base/resources/values-large-v11/styles.xml +@@ -25,16 +25,17 @@ + <item name="android:layout_marginTop">6dp</item> + <item name="android:layout_marginBottom">6dp</item> + <!-- Start with forward hidden --> + <item name="android:orientation">horizontal</item> + </style> + + <style name="TabsList" parent="TabsListBase"> + <item name="android:orientation">horizontal</item> ++ <item name="android:scrollbars">horizontal</item> + </style> + + <style name="TabsItem"> + <item name="android:nextFocusDown">@+id/close</item> + </style> + + <style name="TabsItemClose"> + <item name="android:nextFocusUp">@+id/info</item> +diff --git a/mobile/android/base/resources/values/styles.xml b/mobile/android/base/resources/values/styles.xml +index a15f72e..f479180 100644 +--- a/mobile/android/base/resources/values/styles.xml ++++ b/mobile/android/base/resources/values/styles.xml +@@ -430,16 +430,17 @@ + <!-- TabsTray List --> + <style name="TabsListBase"> + <item name="android:background">@android:color/transparent</item> + <item name="android:listSelector">@android:color/transparent</item> + </style> + + <style name="TabsList" parent="TabsListBase"> + <item name="android:orientation">vertical</item> ++ <item name="android:scrollbars">vertical</item> + </style> + + <style name="TabsItem"> + <item name="android:nextFocusRight">@+id/close</item> + </style> + + <style name="TabsItemClose"> + <item name="android:nextFocusLeft">@+id/info</item> diff --git a/data/patches/gnuzilla-bug-1034167-2.patch b/data/patches/gnuzilla-bug-1034167-2.patch new file mode 100644 index 0000000..3df67a0 --- /dev/null +++ b/data/patches/gnuzilla-bug-1034167-2.patch @@ -0,0 +1,1205 @@ +# HG changeset patch +# User Lucas Rocha <lucasr@mozilla.com> + +Bug 1034167 - Part 1: Update TwoWayView from upstream (r=mfinkle) + +diff --git a/mobile/android/base/resources/values/attrs.xml b/mobile/android/base/resources/values/attrs.xml +index 0c27b87..7140292 100644 +--- a/mobile/android/base/resources/values/attrs.xml ++++ b/mobile/android/base/resources/values/attrs.xml +@@ -117,91 +117,20 @@ + + <declare-styleable name="LightweightTheme"> + <attr name="state_light" format="boolean"/> + <attr name="state_dark" format="boolean"/> + <attr name="autoUpdateTheme" format="boolean"/> + </declare-styleable> + + <declare-styleable name="TwoWayView"> +- <!-- Imported from View --> +- <attr name="android:id"/> +- <attr name="android:tag"/> +- <attr name="android:scrollX"/> +- <attr name="android:scrollY"/> +- <attr name="android:background"/> +- <attr name="android:padding"/> +- <attr name="android:paddingLeft"/> +- <attr name="android:paddingTop"/> +- <attr name="android:paddingRight"/> +- <attr name="android:paddingBottom"/> +- <attr name="android:paddingStart"/> +- <attr name="android:paddingEnd"/> +- <attr name="android:focusable"/> +- <attr name="android:focusableInTouchMode"/> +- <attr name="android:visibility"/> +- <attr name="android:fitsSystemWindows"/> +- <attr name="android:scrollbars"/> +- <attr name="android:scrollbarStyle"/> +- <attr name="android:isScrollContainer"/> +- <attr name="android:fadeScrollbars"/> +- <attr name="android:scrollbarFadeDuration"/> +- <attr name="android:scrollbarDefaultDelayBeforeFade"/> +- <attr name="android:scrollbarSize"/> +- <attr name="android:scrollbarThumbHorizontal"/> +- <attr name="android:scrollbarThumbVertical"/> +- <attr name="android:scrollbarTrackHorizontal"/> +- <attr name="android:scrollbarTrackVertical"/> +- <attr name="android:scrollbarAlwaysDrawHorizontalTrack"/> +- <attr name="android:scrollbarAlwaysDrawVerticalTrack"/> +- <attr name="android:fadingEdge"/> +- <attr name="android:requiresFadingEdge"/> +- <attr name="android:fadingEdgeLength"/> +- <attr name="android:nextFocusLeft"/> +- <attr name="android:nextFocusRight"/> +- <attr name="android:nextFocusUp"/> +- <attr name="android:nextFocusDown"/> +- <attr name="android:nextFocusForward"/> +- <attr name="android:clickable"/> +- <attr name="android:longClickable"/> +- <attr name="android:saveEnabled"/> +- <attr name="android:filterTouchesWhenObscured"/> +- <attr name="android:drawingCacheQuality"/> +- <attr name="android:keepScreenOn"/> +- <attr name="android:duplicateParentState"/> +- <attr name="android:minHeight"/> +- <attr name="android:minWidth"/> +- <attr name="android:soundEffectsEnabled"/> +- <attr name="android:hapticFeedbackEnabled"/> +- <attr name="android:contentDescription"/> +- <attr name="android:onClick"/> +- <attr name="android:overScrollMode"/> +- <attr name="android:alpha"/> +- <attr name="android:translationX"/> +- <attr name="android:translationY"/> +- <attr name="android:transformPivotX"/> +- <attr name="android:transformPivotY"/> +- <attr name="android:rotation"/> +- <attr name="android:rotationX"/> +- <attr name="android:rotationY"/> +- <attr name="android:scaleX"/> +- <attr name="android:scaleY"/> +- <attr name="android:verticalScrollbarPosition"/> +- <attr name="android:layerType"/> +- <attr name="android:layoutDirection"/> +- <attr name="android:textDirection"/> +- <attr name="android:textAlignment"/> +- +- <!-- Imported from Android --> + <attr name="android:orientation"/> +- +- <!-- Imported from AbsListView --> + <attr name="android:choiceMode"/> +- <attr name="android:drawSelectorOnTop"/> + <attr name="android:listSelector"/> ++ <attr name="android:drawSelectorOnTop"/> + </declare-styleable> + + <declare-styleable name="HomeListView"> + <!-- Draws a divider on top of the list, if true. Defaults to false. --> + <attr name="topDivider" format="boolean"/> + </declare-styleable> + + <declare-styleable name="HomePagerTabStrip"> +--- a/mobile/android/base/widget/TwoWayView.java 2015-01-06 05:07:55.000000000 +0000 ++++ b/mobile/android/base/widget/TwoWayView.java 2015-02-23 19:46:01.737065730 +0000 +@@ -23,6 +23,9 @@ + + import org.mozilla.gecko.R; + ++import java.util.ArrayList; ++import java.util.List; ++ + import android.annotation.TargetApi; + import android.content.Context; + import android.content.res.TypedArray; +@@ -67,8 +70,7 @@ + import android.widget.ListAdapter; + import android.widget.Scroller; + +-import java.util.ArrayList; +-import java.util.List; ++import static android.os.Build.VERSION_CODES.HONEYCOMB; + + /* + * Implementation Notes: +@@ -136,8 +138,8 @@ + + public static enum Orientation { + HORIZONTAL, +- VERTICAL; +- }; ++ VERTICAL ++ } + + private ListAdapter mAdapter; + +@@ -266,7 +268,7 @@ + * Callback method to be invoked while the list view or grid view is being scrolled. If the + * view is being scrolled, this method will be called before the next frame of the scroll is + * rendered. In particular, it will be called before any calls to +- * {@link Adapter#getView(int, View, ViewGroup)}. ++ * {@link android.widget.Adapter#getView(int, View, ViewGroup)}. + * + * @param view The view whose scroll state is being reported + * +@@ -388,7 +390,6 @@ + ViewCompat.setOverScrollMode(this, ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS); + + TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.TwoWayView, defStyle, 0); +- initializeScrollbars(a); + + mDrawSelectorOnTop = a.getBoolean( + R.styleable.TwoWayView_android_drawSelectorOnTop, false); +@@ -409,19 +410,16 @@ + } + + a.recycle(); +- +- updateScrollbarsDirection(); + } + + public void setOrientation(Orientation orientation) { +- final boolean isVertical = (orientation.compareTo(Orientation.VERTICAL) == 0); ++ final boolean isVertical = (orientation == Orientation.VERTICAL); + if (mIsVertical == isVertical) { + return; + } + + mIsVertical = isVertical; + +- updateScrollbarsDirection(); + resetState(); + mRecycler.clear(); + +@@ -441,6 +439,7 @@ + requestLayout(); + } + ++ @SuppressWarnings("unused") + public int getItemMargin() { + return mItemMargin; + } +@@ -451,6 +450,7 @@ + * + * @param itemsCanFocus true if items can get focus, false otherwise + */ ++ @SuppressWarnings("unused") + public void setItemsCanFocus(boolean itemsCanFocus) { + mItemsCanFocus = itemsCanFocus; + if (!itemsCanFocus) { +@@ -462,6 +462,7 @@ + * @return Whether the views created by the ListAdapter can contain focusable + * items. + */ ++ @SuppressWarnings("unused") + public boolean getItemsCanFocus() { + return mItemsCanFocus; + } +@@ -481,7 +482,7 @@ + * the recycler for later reuse. This listener can be used to free resources + * associated to the View. + * +- * @param listener The recycler listener to be notified of views set aside ++ * @param l The recycler listener to be notified of views set aside + * in the recycler. + * + * @see TwoWayView.RecycleBin +@@ -495,11 +496,12 @@ + * Controls whether the selection highlight drawable should be drawn on top of the item or + * behind it. + * +- * @param onTop If true, the selector will be drawn on the item it is highlighting. The default +- * is false. ++ * @param drawSelectorOnTop If true, the selector will be drawn on the item it is highlighting. ++ * The default is false. + * + * @attr ref android.R.styleable#AbsListView_drawSelectorOnTop + */ ++ @SuppressWarnings("unused") + public void setDrawSelectorOnTop(boolean drawSelectorOnTop) { + mDrawSelectorOnTop = drawSelectorOnTop; + } +@@ -511,6 +513,7 @@ + * + * @attr ref android.R.styleable#AbsListView_listSelector + */ ++ @SuppressWarnings("unused") + public void setSelector(int resID) { + setSelector(getResources().getDrawable(resID)); + } +@@ -542,6 +545,7 @@ + * + * @return the drawable used to display the selector + */ ++ @SuppressWarnings("unused") + public Drawable getSelector() { + return mSelector; + } +@@ -564,7 +568,7 @@ + + /** + * Returns the number of items currently selected. This will only be valid +- * if the choice mode is not {@link #CHOICE_MODE_NONE} (default). ++ * if the choice mode is not {@link ChoiceMode#NONE} (default). + * + * <p>To determine the specific items that are currently selected, use one of + * the <code>getChecked*</code> methods. +@@ -575,23 +579,24 @@ + * @see #getCheckedItemPositions() + * @see #getCheckedItemIds() + */ ++ @SuppressWarnings("unused") + public int getCheckedItemCount() { + return mCheckedItemCount; + } + + /** + * Returns the checked state of the specified position. The result is only +- * valid if the choice mode has been set to {@link #CHOICE_MODE_SINGLE} +- * or {@link #CHOICE_MODE_MULTIPLE}. ++ * valid if the choice mode has been set to {@link ChoiceMode#SINGLE} ++ * or {@link ChoiceMode#MULTIPLE}. + * + * @param position The item whose checked state to return + * @return The item's checked state or <code>false</code> if choice mode + * is invalid + * +- * @see #setChoiceMode(int) ++ * @see #setChoiceMode(ChoiceMode) + */ + public boolean isItemChecked(int position) { +- if (mChoiceMode.compareTo(ChoiceMode.NONE) == 0 && mCheckStates != null) { ++ if (mChoiceMode == ChoiceMode.NONE && mCheckStates != null) { + return mCheckStates.get(position); + } + +@@ -600,16 +605,15 @@ + + /** + * Returns the currently checked item. The result is only valid if the choice +- * mode has been set to {@link #CHOICE_MODE_SINGLE}. ++ * mode has been set to {@link ChoiceMode#SINGLE}. + * + * @return The position of the currently checked item or + * {@link #INVALID_POSITION} if nothing is selected + * +- * @see #setChoiceMode(int) ++ * @see #setChoiceMode(ChoiceMode) + */ + public int getCheckedItemPosition() { +- if (mChoiceMode.compareTo(ChoiceMode.SINGLE) == 0 && +- mCheckStates != null && mCheckStates.size() == 1) { ++ if (mChoiceMode == ChoiceMode.SINGLE && mCheckStates != null && mCheckStates.size() == 1) { + return mCheckStates.keyAt(0); + } + +@@ -618,15 +622,15 @@ + + /** + * Returns the set of checked items in the list. The result is only valid if +- * the choice mode has not been set to {@link #CHOICE_MODE_NONE}. ++ * the choice mode has not been set to {@link ChoiceMode#NONE}. + * + * @return A SparseBooleanArray which will return true for each call to + * get(int position) where position is a position in the list, + * or <code>null</code> if the choice mode is set to +- * {@link #CHOICE_MODE_NONE}. ++ * {@link ChoiceMode#NONE}. + */ + public SparseBooleanArray getCheckedItemPositions() { +- if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0) { ++ if (mChoiceMode != ChoiceMode.NONE) { + return mCheckStates; + } + +@@ -635,15 +639,14 @@ + + /** + * Returns the set of checked items ids. The result is only valid if the +- * choice mode has not been set to {@link #CHOICE_MODE_NONE} and the adapter ++ * choice mode has not been set to {@link ChoiceMode#NONE} and the adapter + * has stable IDs. ({@link ListAdapter#hasStableIds()} == {@code true}) + * + * @return A new array which contains the id of each checked item in the + * list. + */ + public long[] getCheckedItemIds() { +- if (mChoiceMode.compareTo(ChoiceMode.NONE) == 0 || +- mCheckedIdStates == null || mAdapter == null) { ++ if (mChoiceMode == ChoiceMode.NONE || mCheckedIdStates == null || mAdapter == null) { + return new long[0]; + } + +@@ -660,18 +663,19 @@ + + /** + * Sets the checked state of the specified position. The is only valid if +- * the choice mode has been set to {@link #CHOICE_MODE_SINGLE} or +- * {@link #CHOICE_MODE_MULTIPLE}. ++ * the choice mode has been set to {@link ChoiceMode#SINGLE} or ++ * {@link ChoiceMode#MULTIPLE}. + * + * @param position The item whose checked state is to be checked + * @param value The new checked state for the item + */ ++ @SuppressWarnings("unused") + public void setItemChecked(int position, boolean value) { +- if (mChoiceMode.compareTo(ChoiceMode.NONE) == 0) { ++ if (mChoiceMode == ChoiceMode.NONE) { + return; + } + +- if (mChoiceMode.compareTo(ChoiceMode.MULTIPLE) == 0) { ++ if (mChoiceMode == ChoiceMode.MULTIPLE) { + boolean oldValue = mCheckStates.get(position); + mCheckStates.put(position, value); + +@@ -729,6 +733,7 @@ + /** + * Clear any choices previously set + */ ++ @SuppressWarnings("unused") + public void clearChoices() { + if (mCheckStates != null) { + mCheckStates.clear(); +@@ -742,27 +747,28 @@ + } + + /** +- * @see #setChoiceMode(int) ++ * @see #setChoiceMode(ChoiceMode) + * + * @return The current choice mode + */ ++ @SuppressWarnings("unused") + public ChoiceMode getChoiceMode() { + return mChoiceMode; + } + + /** + * Defines the choice behavior for the List. By default, Lists do not have any choice behavior +- * ({@link #CHOICE_MODE_NONE}). By setting the choiceMode to {@link #CHOICE_MODE_SINGLE}, the ++ * ({@link ChoiceMode#NONE}). By setting the choiceMode to {@link ChoiceMode#SINGLE}, the + * List allows up to one item to be in a chosen state. By setting the choiceMode to +- * {@link #CHOICE_MODE_MULTIPLE}, the list allows any number of items to be chosen. ++ * {@link ChoiceMode#MULTIPLE}, the list allows any number of items to be chosen. + * +- * @param choiceMode One of {@link #CHOICE_MODE_NONE}, {@link #CHOICE_MODE_SINGLE}, or +- * {@link #CHOICE_MODE_MULTIPLE} ++ * @param choiceMode One of {@link ChoiceMode#NONE}, {@link ChoiceMode#SINGLE}, or ++ * {@link ChoiceMode#MULTIPLE} + */ + public void setChoiceMode(ChoiceMode choiceMode) { + mChoiceMode = choiceMode; + +- if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0) { ++ if (mChoiceMode != ChoiceMode.NONE) { + if (mCheckStates == null) { + mCheckStates = new SparseBooleanArray(); + } +@@ -813,8 +819,7 @@ + mHasStableIds = adapter.hasStableIds(); + mAreAllItemsSelectable = adapter.areAllItemsEnabled(); + +- if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0 && mHasStableIds && +- mCheckedIdStates == null) { ++ if (mChoiceMode != ChoiceMode.NONE && mHasStableIds && mCheckedIdStates == null) { + mCheckedIdStates = new LongSparseArray<Integer>(); + } + +@@ -1268,7 +1273,7 @@ + + @Override + public boolean onInterceptTouchEvent(MotionEvent ev) { +- if (!mIsAttached) { ++ if (!mIsAttached || mAdapter == null) { + return false; + } + +@@ -1354,7 +1359,7 @@ + return isClickable() || isLongClickable(); + } + +- if (!mIsAttached) { ++ if (!mIsAttached || mAdapter == null) { + return false; + } + +@@ -1477,7 +1482,7 @@ + final float x = ev.getX(); + final float y = ev.getY(); + +- boolean inList = false; ++ final boolean inList; + if (mIsVertical) { + inList = x > getPaddingLeft() && x < getWidth() - getPaddingRight(); + } else { +@@ -1731,7 +1736,7 @@ + } + + // TODO: Use some form of smooth scroll instead +- trackMotionScroll(viewportSize); ++ scrollListItemsBy(viewportSize); + return true; + } + return false; +@@ -1746,7 +1751,7 @@ + } + + // TODO: Use some form of smooth scroll instead +- trackMotionScroll(-viewportSize); ++ scrollListItemsBy(-viewportSize); + return true; + } + return false; +@@ -2077,7 +2082,7 @@ + newFocus = FocusFinder.getInstance().findNextFocus(this, oldFocus, direction); + } else { + if (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT) { +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); ++ final int start = getStartEdge(); + + final int selectedStart; + if (selectedView != null) { +@@ -2088,12 +2093,11 @@ + + searchPoint = Math.max(selectedStart, start); + } else { +- final int end = (mIsVertical ? getHeight() - getPaddingBottom() : +- getWidth() - getPaddingRight()); ++ final int end = getEndEdge(); + + final int selectedEnd; + if (selectedView != null) { +- selectedEnd = (mIsVertical ? selectedView.getBottom() : selectedView.getRight()); ++ selectedEnd = getChildEndEdge(selectedView); + } else { + selectedEnd = end; + } +@@ -2242,7 +2246,7 @@ + } + + if (amountToScroll > 0) { +- trackMotionScroll(direction == View.FOCUS_UP || direction == View.FOCUS_LEFT ? ++ scrollListItemsBy(direction == View.FOCUS_UP || direction == View.FOCUS_LEFT ? + amountToScroll : -amountToScroll); + needToRedraw = true; + } +@@ -2304,8 +2308,7 @@ + final int numChildren = getChildCount(); + + if (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT) { +- final int end = (mIsVertical ? getHeight() - getPaddingBottom() : +- getWidth() - getPaddingRight()); ++ final int end = getEndEdge(); + + int indexToMakeVisible = numChildren - 1; + if (nextSelectedPosition != INVALID_POSITION) { +@@ -2320,10 +2323,8 @@ + goalEnd -= getArrowScrollPreviewLength(); + } + +- final int viewToMakeVisibleStart = +- (mIsVertical ? viewToMakeVisible.getTop() : viewToMakeVisible.getLeft()); +- final int viewToMakeVisibleEnd = +- (mIsVertical ? viewToMakeVisible.getBottom() : viewToMakeVisible.getRight()); ++ final int viewToMakeVisibleStart = getChildStartEdge(viewToMakeVisible); ++ final int viewToMakeVisibleEnd = getChildEndEdge(viewToMakeVisible); + + if (viewToMakeVisibleEnd <= goalEnd) { + // Target item is fully visible +@@ -2339,8 +2340,7 @@ + int amountToScroll = (viewToMakeVisibleEnd - goalEnd); + + if (mFirstPosition + numChildren == mItemCount) { +- final View lastChild = getChildAt(numChildren - 1); +- final int lastChildEnd = (mIsVertical ? lastChild.getBottom() : lastChild.getRight()); ++ final int lastChildEnd = getChildEndEdge(getChildAt(numChildren - 1)); + + // Last is last in list -> Make sure we don't scroll past it + final int max = lastChildEnd - end; +@@ -2349,7 +2349,7 @@ + + return Math.min(amountToScroll, getMaxScrollAmount()); + } else { +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); ++ final int start = getStartEdge(); + + int indexToMakeVisible = 0; + if (nextSelectedPosition != INVALID_POSITION) { +@@ -2364,10 +2364,8 @@ + goalStart += getArrowScrollPreviewLength(); + } + +- final int viewToMakeVisibleStart = +- (mIsVertical ? viewToMakeVisible.getTop() : viewToMakeVisible.getLeft()); +- final int viewToMakeVisibleEnd = +- (mIsVertical ? viewToMakeVisible.getBottom() : viewToMakeVisible.getRight()); ++ final int viewToMakeVisibleStart = getChildStartEdge(viewToMakeVisible); ++ final int viewToMakeVisibleEnd = getChildEndEdge(viewToMakeVisible); + + if (viewToMakeVisibleStart >= goalStart) { + // Item is fully visible +@@ -2383,8 +2381,7 @@ + int amountToScroll = (goalStart - viewToMakeVisibleStart); + + if (mFirstPosition == 0) { +- final View firstChild = getChildAt(0); +- final int firstChildStart = (mIsVertical ? firstChild.getTop() : firstChild.getLeft()); ++ final int firstChildStart = getChildStartEdge(getChildAt(0)); + + // First is first in list -> make sure we don't scroll past it + final int max = start - firstChildStart; +@@ -2416,7 +2413,7 @@ + offsetDescendantRectToMyCoords(newFocus, mTempRect); + + if (direction == View.FOCUS_UP || direction == View.FOCUS_LEFT) { +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); ++ final int start = getStartEdge(); + final int newFocusStart = (mIsVertical ? mTempRect.top : mTempRect.left); + + if (newFocusStart < start) { +@@ -2426,8 +2423,7 @@ + } + } + } else { +- final int end = (mIsVertical ? getHeight() - getPaddingBottom() : +- getWidth() - getPaddingRight()); ++ final int end = getEndEdge(); + final int newFocusEnd = (mIsVertical ? mTempRect.bottom : mTempRect.right); + + if (newFocusEnd > end) { +@@ -2452,9 +2448,8 @@ + descendant.getDrawingRect(mTempRect); + offsetDescendantRectToMyCoords(descendant, mTempRect); + +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); +- final int end = (mIsVertical ? getHeight() - getPaddingBottom() : +- getWidth() - getPaddingRight()); ++ final int start = getStartEdge(); ++ final int end = getEndEdge(); + + final int viewStart = (mIsVertical ? mTempRect.top : mTempRect.left); + final int viewEnd = (mIsVertical ? mTempRect.bottom : mTempRect.right); +@@ -2741,7 +2736,7 @@ + motionViewPrevStart = (mIsVertical ? motionView.getTop() : motionView.getLeft()); + } + +- boolean atEdge = trackMotionScroll(delta); ++ boolean atEdge = scrollListItemsBy(delta); + + motionView = this.getChildAt(motionIndex); + if (motionView != null) { +@@ -2821,7 +2816,7 @@ + ViewCompat.postInvalidateOnAnimation(this); + } + +- trackMotionScroll(delta); ++ scrollListItemsBy(delta); + mTouchMode = TOUCH_MODE_DRAGGING; + + // We did not scroll the full amount. Treat this essentially like the +@@ -2901,10 +2896,8 @@ + } + + for (int i = 0; i < childCount; i++) { +- View v = getChildAt(i); +- +- if ((mIsVertical && motionPos <= v.getBottom()) || +- (!mIsVertical && motionPos <= v.getRight())) { ++ final View v = getChildAt(i); ++ if (motionPos <= getChildEndEdge(v)) { + return mFirstPosition + i; + } + } +@@ -2935,6 +2928,26 @@ + return vc.getScaledOverscrollDistance(); + } + ++ private int getStartEdge() { ++ return (mIsVertical ? getPaddingTop() : getPaddingLeft()); ++ } ++ ++ private int getEndEdge() { ++ if (mIsVertical) { ++ return (getHeight() - getPaddingBottom()); ++ } else { ++ return (getWidth() - getPaddingRight()); ++ } ++ } ++ ++ private int getChildStartEdge(View child) { ++ return (mIsVertical ? child.getTop() : child.getLeft()); ++ } ++ ++ private int getChildEndEdge(View child) { ++ return (mIsVertical ? child.getBottom() : child.getRight()); ++ } ++ + private boolean contentFits() { + final int childCount = getChildCount(); + if (childCount == 0) { +@@ -2948,18 +2961,8 @@ + View first = getChildAt(0); + View last = getChildAt(childCount - 1); + +- if (mIsVertical) { +- return first.getTop() >= getPaddingTop() && +- last.getBottom() <= getHeight() - getPaddingBottom(); +- } else { +- return first.getLeft() >= getPaddingLeft() && +- last.getRight() <= getWidth() - getPaddingRight(); +- } +- } +- +- private void updateScrollbarsDirection() { +- setHorizontalScrollBarEnabled(!mIsVertical); +- setVerticalScrollBarEnabled(mIsVertical); ++ return (getChildStartEdge(first) >= getStartEdge() && ++ getChildEndEdge(last) <= getEndEdge()); + } + + private void triggerCheckForTap() { +@@ -2997,17 +3000,14 @@ + removeCallbacks(mPendingCheckForLongPress); + } + +- boolean trackMotionScroll(int incrementalDelta) { ++ private boolean scrollListItemsBy(int incrementalDelta) { + final int childCount = getChildCount(); + if (childCount == 0) { + return true; + } + +- final View first = getChildAt(0); +- final int firstStart = (mIsVertical ? first.getTop() : first.getLeft()); +- +- final View last = getChildAt(childCount - 1); +- final int lastEnd = (mIsVertical ? last.getBottom() : last.getRight()); ++ final int firstStart = getChildStartEdge(getChildAt(0)); ++ final int lastEnd = getChildEndEdge(getChildAt(childCount - 1)); + + final int paddingTop = getPaddingTop(); + final int paddingBottom = getPaddingBottom(); +@@ -3017,8 +3017,7 @@ + final int paddingStart = (mIsVertical ? paddingTop : paddingLeft); + + final int spaceBefore = paddingStart - firstStart; +- final int end = (mIsVertical ? getHeight() - paddingBottom : +- getWidth() - paddingRight); ++ final int end = getEndEdge(); + final int spaceAfter = lastEnd - end; + + final int size; +@@ -3059,7 +3058,7 @@ + + for (int i = 0; i < childCount; i++) { + final View child = getChildAt(i); +- final int childEnd = (mIsVertical ? child.getBottom() : child.getRight()); ++ final int childEnd = getChildEndEdge(child); + + if (childEnd >= childrenStart) { + break; +@@ -3073,7 +3072,7 @@ + + for (int i = childCount - 1; i >= 0; i--) { + final View child = getChildAt(i); +- final int childStart = (mIsVertical ? child.getTop() : child.getLeft()); ++ final int childStart = getChildStartEdge(child); + + if (childStart <= childrenEnd) { + break; +@@ -3140,11 +3139,7 @@ + + @TargetApi(5) + private boolean awakenScrollbarsInternal() { +- if (Build.VERSION.SDK_INT >= 5) { +- return super.awakenScrollBars(); +- } else { +- return false; +- } ++ return (Build.VERSION.SDK_INT >= 5) && super.awakenScrollBars(); + } + + @Override +@@ -3163,7 +3158,7 @@ + final int diff = (int) (pos - mLastTouchPos); + mLastTouchPos = pos; + +- final boolean stopped = trackMotionScroll(diff); ++ final boolean stopped = scrollListItemsBy(diff); + + if (!stopped && !mScroller.isFinished()) { + ViewCompat.postInvalidateOnAnimation(this); +@@ -3210,7 +3205,7 @@ + } + + final int restoreCount = canvas.save(); +- final int height = getHeight() - getPaddingTop() - getPaddingBottom(); ++ final int height = getHeight(); + + canvas.translate(0, height); + canvas.rotate(270); +@@ -3226,8 +3221,8 @@ + } + + final int restoreCount = canvas.save(); +- final int width = getWidth() - getPaddingLeft() - getPaddingRight(); +- final int height = getHeight() - getPaddingTop() - getPaddingBottom(); ++ final int width = getWidth(); ++ final int height = getHeight(); + + if (mIsVertical) { + canvas.translate(-width, height); +@@ -3683,6 +3678,10 @@ + } + } + ++ public void scrollBy(int offset) { ++ scrollListItemsBy(offset); ++ } ++ + @Override + public boolean dispatchKeyEvent(KeyEvent event) { + // Dispatch in the normal way +@@ -3814,9 +3813,8 @@ + return; + } + +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); +- final int end = +- (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight()); ++ final int start = getStartEdge(); ++ final int end = getEndEdge(); + + int childCount = getChildCount(); + int index = 0; +@@ -4084,8 +4082,8 @@ + int end) { + final int selectedPosition = mSelectedPosition; + +- final int oldSelectedStart = (mIsVertical ? oldSelected.getTop() : oldSelected.getLeft()); +- final int oldSelectedEnd = (mIsVertical ? oldSelected.getBottom() : oldSelected.getRight()); ++ final int oldSelectedStart = getChildStartEdge(oldSelected); ++ final int oldSelectedEnd = getChildEndEdge(oldSelected); + + View selected = null; + +@@ -4118,8 +4116,8 @@ + // Now put the new selection (B) below that + selected = makeAndAddView(selectedPosition, oldSelectedEnd + itemMargin, true, true); + +- final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft()); +- final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight()); ++ final int selectedStart = getChildStartEdge(selected); ++ final int selectedEnd = getChildEndEdge(selected); + + // Some of the newly selected item extends below the bottom of the list + if (selectedEnd > end) { +@@ -4178,8 +4176,8 @@ + selected = makeAndAddView(selectedPosition, oldSelectedStart, false, true); + } + +- final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft()); +- final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight()); ++ final int selectedStart = getChildStartEdge(selected); ++ final int selectedEnd = getChildEndEdge(selected); + + // Some of the newly selected item extends above the top of the list + if (selectedStart < start) { +@@ -4210,8 +4208,8 @@ + + selected = makeAndAddView(selectedPosition, oldSelectedStart, true, true); + +- final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft()); +- final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight()); ++ final int selectedStart = getChildStartEdge(selected); ++ final int selectedEnd = getChildEndEdge(selected); + + // We're staying still... + if (oldSelectedStart < start) { +@@ -4272,7 +4270,7 @@ + } + + private void handleDataChanged() { +- if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0 && mAdapter != null && mAdapter.hasStableIds()) { ++ if (mChoiceMode != ChoiceMode.NONE && mAdapter != null && mAdapter.hasStableIds()) { + confirmCheckedPositionsById(); + } + +@@ -4406,9 +4404,8 @@ + int selectedStart = 0; + int selectedPosition; + +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); +- final int end = +- (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight()); ++ final int start = getStartEdge(); ++ final int end = getEndEdge(); + + final int firstPosition = mFirstPosition; + final int toPosition = mResurrectToPosition; +@@ -4445,8 +4442,8 @@ + + for (int i = childCount - 1; i >= 0; i--) { + final View child = getChildAt(i); +- final int childStart = (mIsVertical ? child.getTop() : child.getLeft()); +- final int childEnd = (mIsVertical ? child.getBottom() : child.getRight()); ++ final int childStart = getChildStartEdge(child); ++ final int childEnd = getChildEndEdge(child); + + if (i == childCount - 1) { + selectedStart = childStart; +@@ -4718,7 +4715,7 @@ + recycleBin.addScrapView(child, -1); + } + +- returnedWidth += child.getMeasuredHeight(); ++ returnedWidth += child.getMeasuredWidth(); + + if (returnedWidth >= maxWidth) { + // We went over, figure out which width to return. If returnedWidth > maxWidth, +@@ -4810,11 +4807,10 @@ + child.setPressed(isPressed); + } + +- if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0 && mCheckStates != null) { ++ if (mChoiceMode != ChoiceMode.NONE && mCheckStates != null) { + if (child instanceof Checkable) { + ((Checkable) child).setChecked(mCheckStates.get(position)); +- } else if (getContext().getApplicationInfo().targetSdkVersion +- >= Build.VERSION_CODES.HONEYCOMB) { ++ } else if (Build.VERSION.SDK_INT >= HONEYCOMB) { + child.setActivated(mCheckStates.get(position)); + } + } +@@ -4847,26 +4843,17 @@ + + if (down) { + final int paddingStart = (mIsVertical ? getPaddingTop() : getPaddingLeft()); +- +- final int lastEnd; +- if (mIsVertical) { +- lastEnd = getChildAt(childCount - 1).getBottom(); +- } else { +- lastEnd = getChildAt(childCount - 1).getRight(); +- } ++ final int lastEnd = getChildEndEdge(getChildAt(childCount - 1)); + + final int offset = (childCount > 0 ? lastEnd + mItemMargin : paddingStart); + fillAfter(mFirstPosition + childCount, offset); + correctTooHigh(getChildCount()); + } else { +- final int end; ++ final int end = getEndEdge(); + final int firstStart; +- + if (mIsVertical) { +- end = getHeight() - getPaddingBottom(); + firstStart = getChildAt(0).getTop(); + } else { +- end = getWidth() - getPaddingRight(); + firstStart = getChildAt(0).getLeft(); + } + +@@ -4879,7 +4866,7 @@ + private View fillBefore(int pos, int nextOffset) { + View selectedView = null; + +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); ++ final int start = getStartEdge(); + + while (nextOffset > start && pos >= 0) { + boolean isSelected = (pos == mSelectedPosition); +@@ -4906,19 +4893,13 @@ + private View fillAfter(int pos, int nextOffset) { + View selectedView = null; + +- final int end = +- (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight()); ++ final int end = getEndEdge(); + + while (nextOffset < end && pos < mItemCount) { + boolean selected = (pos == mSelectedPosition); + + View child = makeAndAddView(pos, nextOffset, true, selected); +- +- if (mIsVertical) { +- nextOffset = child.getBottom() + mItemMargin; +- } else { +- nextOffset = child.getRight() + mItemMargin; +- } ++ nextOffset = getChildEndEdge(child) + mItemMargin; + + if (selected) { + selectedView = child; +@@ -4937,25 +4918,13 @@ + // Possibly changed again in fillBefore if we add rows above this one. + mFirstPosition = position; + +- final int itemMargin = mItemMargin; +- +- final int offsetBefore; +- if (mIsVertical) { +- offsetBefore = temp.getTop() - itemMargin; +- } else { +- offsetBefore = temp.getLeft() - itemMargin; +- } ++ final int offsetBefore = getChildStartEdge(temp) + mItemMargin; + final View before = fillBefore(position - 1, offsetBefore); + + // This will correct for the top of the first view not touching the top of the list + adjustViewsStartOrEnd(); + +- final int offsetAfter; +- if (mIsVertical) { +- offsetAfter = temp.getBottom() + itemMargin; +- } else { +- offsetAfter = temp.getRight() + itemMargin; +- } ++ final int offsetAfter = getChildEndEdge(temp) + mItemMargin; + final View after = fillAfter(position + 1, offsetAfter); + + final int childCount = getChildCount(); +@@ -5009,37 +4978,22 @@ + } + + private void fillBeforeAndAfter(View selected, int position) { +- final int itemMargin = mItemMargin; +- +- final int offsetBefore; +- if (mIsVertical) { +- offsetBefore = selected.getTop() - itemMargin; +- } else { +- offsetBefore = selected.getLeft() - itemMargin; +- } +- ++ final int offsetBefore = getChildStartEdge(selected) + mItemMargin; + fillBefore(position - 1, offsetBefore); + + adjustViewsStartOrEnd(); + +- final int offsetAfter; +- if (mIsVertical) { +- offsetAfter = selected.getBottom() + itemMargin; +- } else { +- offsetAfter = selected.getRight() + itemMargin; +- } +- ++ final int offsetAfter = getChildEndEdge(selected) + mItemMargin; + fillAfter(position + 1, offsetAfter); + } + + private View fillFromSelection(int selectedTop, int start, int end) { + final int selectedPosition = mSelectedPosition; +- View selected; + +- selected = makeAndAddView(selectedPosition, selectedTop, true, true); ++ View selected = makeAndAddView(selectedPosition, selectedTop, true, true); + +- final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft()); +- final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight()); ++ final int selectedStart = getChildStartEdge(selected); ++ final int selectedEnd = getChildEndEdge(selected); + + // Some of the newly selected item extends below the bottom of the list + if (selectedEnd > end) { +@@ -5085,28 +5039,19 @@ + return; + } + +- // Get the last child ... +- final View lastChild = getChildAt(childCount - 1); +- +- // ... and its end edge +- final int lastEnd; +- if (mIsVertical) { +- lastEnd = lastChild.getBottom(); +- } else { +- lastEnd = lastChild.getRight(); +- } ++ // Get the last child end edge ++ final int lastEnd = getChildEndEdge(getChildAt(childCount - 1)); + + // This is bottom of our drawable area +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); +- final int end = +- (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight()); ++ final int start = getStartEdge(); ++ final int end = getEndEdge(); + + // This is how far the end edge of the last view is from the end of the + // drawable area + int endOffset = end - lastEnd; + + View firstChild = getChildAt(0); +- int firstStart = (mIsVertical ? firstChild.getTop() : firstChild.getLeft()); ++ int firstStart = getChildStartEdge(firstChild); + + // Make sure we are 1) Too high, and 2) Either there are more rows above the + // first row or the first row is scrolled off the top of the drawable area +@@ -5120,7 +5065,7 @@ + offsetChildren(endOffset); + + if (mFirstPosition > 0) { +- firstStart = (mIsVertical ? firstChild.getTop() : firstChild.getLeft()); ++ firstStart = getChildStartEdge(firstChild); + + // Fill the gap that was opened above mFirstPosition with more rows, if + // possible +@@ -5142,21 +5087,15 @@ + final View first = getChildAt(0); + final int firstStart = (mIsVertical ? first.getTop() : first.getLeft()); + +- final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft()); +- +- final int end; +- if (mIsVertical) { +- end = getHeight() - getPaddingBottom(); +- } else { +- end = getWidth() - getPaddingRight(); +- } ++ final int start = getStartEdge(); ++ final int end = getEndEdge(); + + // This is how far the start edge of the first view is from the start of the + // drawable area + int startOffset = firstStart - start; + + View last = getChildAt(childCount - 1); +- int lastEnd = (mIsVertical ? last.getBottom() : last.getRight()); ++ int lastEnd = getChildEndEdge(last); + + int lastPosition = mFirstPosition + childCount - 1; + +@@ -5174,7 +5113,7 @@ + offsetChildren(-startOffset); + + if (lastPosition < mItemCount - 1) { +- lastEnd = (mIsVertical ? last.getBottom() : last.getRight()); ++ lastEnd = getChildEndEdge(last); + + // Fill the gap that was opened below the last position with more rows, if + // possible +@@ -5366,6 +5305,8 @@ + } + + void resetState() { ++ mScroller.forceFinished(true); ++ + removeAllViewsInLayout(); + + mSelectedStart = 0; +@@ -5419,7 +5360,7 @@ + mSyncPosition = mFirstPosition; + + if (child != null) { +- mSpecificStart = child.getTop(); ++ mSpecificStart = (mIsVertical ? child.getTop() : child.getLeft()); + } + + mSyncMode = SYNC_FIRST_POSITION; +@@ -5435,16 +5376,13 @@ + final int firstPos = mFirstPosition; + final int count = getChildCount(); + +- final boolean useActivated = getContext().getApplicationInfo().targetSdkVersion +- >= Build.VERSION_CODES.HONEYCOMB; +- + for (int i = 0; i < count; i++) { + final View child = getChildAt(i); + final int position = firstPos + i; + + if (child instanceof Checkable) { + ((Checkable) child).setChecked(mCheckStates.get(position)); +- } else if (useActivated) { ++ } else if (Build.VERSION.SDK_INT >= HONEYCOMB) { + child.setActivated(mCheckStates.get(position)); + } + } +@@ -5454,7 +5392,7 @@ + public boolean performItemClick(View view, int position, long id) { + boolean checkedStateChanged = false; + +- if (mChoiceMode.compareTo(ChoiceMode.MULTIPLE) == 0) { ++ if (mChoiceMode == ChoiceMode.MULTIPLE) { + boolean checked = !mCheckStates.get(position, false); + mCheckStates.put(position, checked); + +@@ -5473,7 +5411,7 @@ + } + + checkedStateChanged = true; +- } else if (mChoiceMode.compareTo(ChoiceMode.SINGLE) == 0) { ++ } else if (mChoiceMode == ChoiceMode.SINGLE) { + boolean checked = !mCheckStates.get(position, false); + if (checked) { + mCheckStates.clear(); +@@ -5699,14 +5637,14 @@ + super(width, height); + + if (this.width == MATCH_PARENT) { +- Log.w(LOGTAG, "Constructing LayoutParams with width FILL_PARENT " + ++ Log.w(LOGTAG, "Constructing LayoutParams with width MATCH_PARENT " + + "does not make much sense as the view might change orientation. " + + "Falling back to WRAP_CONTENT"); + this.width = WRAP_CONTENT; + } + + if (this.height == MATCH_PARENT) { +- Log.w(LOGTAG, "Constructing LayoutParams with height FILL_PARENT " + ++ Log.w(LOGTAG, "Constructing LayoutParams with height MATCH_PARENT " + + "does not make much sense as the view might change orientation. " + + "Falling back to WRAP_CONTENT"); + this.height = WRAP_CONTENT; +@@ -5735,7 +5673,7 @@ + super(other); + + if (this.width == MATCH_PARENT) { +- Log.w(LOGTAG, "Constructing LayoutParams with height MATCH_PARENT - " + ++ Log.w(LOGTAG, "Constructing LayoutParams with width MATCH_PARENT - " + + "does not make much sense as the view might change orientation. " + + "Falling back to WRAP_CONTENT"); + this.width = WRAP_CONTENT; +@@ -5786,11 +5724,8 @@ + } else { + final int typeCount = mViewTypeCount; + for (int i = 0; i < typeCount; i++) { +- final ArrayList<View> scrap = mScrapViews[i]; +- final int scrapCount = scrap.size(); +- +- for (int j = 0; j < scrapCount; j++) { +- scrap.get(j).forceLayout(); ++ for (View scrap : mScrapViews[i]) { ++ scrap.forceLayout(); + } + } + } +@@ -6120,7 +6055,7 @@ + // Force one here to make sure that the state of the list matches + // the state of the adapter. + if (mDataChanged) { +- onLayout(false, getLeft(), getTop(), getRight(), getBottom()); ++ layout(getLeft(), getTop(), getRight(), getBottom()); + } + } else { + if (mEmptyView != null) { +@@ -6525,16 +6460,10 @@ + return false; + + case AccessibilityNodeInfoCompat.ACTION_CLICK: +- if (isClickable()) { +- return performItemClick(host, position, id); +- } +- return false; ++ return isClickable() && performItemClick(host, position, id); + + case AccessibilityNodeInfoCompat.ACTION_LONG_CLICK: +- if (isLongClickable()) { +- return performLongPress(host, position, id); +- } +- return false; ++ return isLongClickable() && performLongPress(host, position, id); + } + + return false; diff --git a/data/patches/gnuzilla-bug-1036286-1.patch b/data/patches/gnuzilla-bug-1036286-1.patch new file mode 100644 index 0000000..a5d3110 --- /dev/null +++ b/data/patches/gnuzilla-bug-1036286-1.patch @@ -0,0 +1,188 @@ +--- a/mozglue/linker/ElfLoader.cpp ++++ a/mozglue/linker/ElfLoader.cpp +@@ -960,28 +960,28 @@ static uint64_t ProcessTimeStamp_Now() + /* Data structure used to pass data to the temporary signal handler, + * as well as triggering a test crash. */ + struct TmpData { + volatile int crash_int; + volatile uint64_t crash_timestamp; + }; + + SEGVHandler::SEGVHandler() +-: registeredHandler(false), signalHandlingBroken(false) +-, signalHandlingSlow(false) ++: initialized(false), registeredHandler(false), signalHandlingBroken(true) ++, signalHandlingSlow(true) + { + /* Initialize oldStack.ss_flags to an invalid value when used to set + * an alternative stack, meaning we haven't got information about the +- * original alternative stack and thus don't mean to restore it */ ++ * original alternative stack and thus don't mean to restore it in ++ * the desctructor. */ + oldStack.ss_flags = SS_ONSTACK; +- if (!Divert(sigaction, __wrap_sigaction)) +- return; + + /* Get the current segfault signal handler. */ +- sys_sigaction(SIGSEGV, nullptr, &this->action); ++ struct sigaction old_action; ++ sys_sigaction(SIGSEGV, nullptr, &old_action); + + /* Some devices don't provide useful information to their SIGSEGV handlers, + * making it impossible for on-demand decompression to work. To check if + * we're on such a device, setup a temporary handler and deliberately + * trigger a segfault. The handler will set signalHandlingBroken if the + * provided information is bogus. + * Some other devices have a kernel option enabled that makes SIGSEGV handler + * have an overhead so high that it affects how on-demand decompression +@@ -1000,21 +1000,33 @@ SEGVHandler::SEGVHandler() + if (sys_sigaction(SIGSEGV, &action, nullptr)) + return; + + TmpData *data = reinterpret_cast<TmpData*>(stackPtr.get()); + data->crash_timestamp = ProcessTimeStamp_Now(); + mprotect(stackPtr, stackPtr.GetLength(), PROT_NONE); + data->crash_int = 123; + /* Restore the original segfault signal handler. */ +- sys_sigaction(SIGSEGV, &this->action, nullptr); ++ sys_sigaction(SIGSEGV, &old_action, nullptr); + stackPtr.Assign(MAP_FAILED, 0); ++} ++ ++void ++SEGVHandler::FinishInitialization() ++{ ++ /* Ideally, we'd need some locking here, but in practice, we're not ++ * going to race with another thread. */ ++ initialized = true; ++ + if (signalHandlingBroken || signalHandlingSlow) + return; + ++ if (!Divert(sigaction, __wrap_sigaction)) ++ return; ++ + /* Setup an alternative stack if the already existing one is not big + * enough, or if there is none. */ + if (sigaltstack(nullptr, &oldStack) == 0) { + if (oldStack.ss_flags == SS_ONSTACK) + oldStack.ss_flags = 0; + if (!oldStack.ss_sp || oldStack.ss_size < stackSize) { + stackPtr.Assign(MemoryRange::mmap(nullptr, stackSize, + PROT_READ | PROT_WRITE, +@@ -1028,17 +1040,17 @@ SEGVHandler::SEGVHandler() + if (sigaltstack(&stack, nullptr) != 0) + return; + } + } + /* Register our own handler, and store the already registered one in + * SEGVHandler's struct sigaction member */ + action.sa_sigaction = &SEGVHandler::handler; + action.sa_flags = SA_SIGINFO | SA_NODEFER | SA_ONSTACK; +- registeredHandler = !sys_sigaction(SIGSEGV, &action, nullptr); ++ registeredHandler = !sys_sigaction(SIGSEGV, &action, &this->action); + } + + SEGVHandler::~SEGVHandler() + { + /* Restore alternative stack for signals */ + if (oldStack.ss_flags != SS_ONSTACK) + sigaltstack(&oldStack, nullptr); + /* Restore original signal handler */ +@@ -1048,28 +1060,28 @@ SEGVHandler::~SEGVHandler() + + /* Test handler for a deliberately triggered SIGSEGV that determines whether + * useful information is provided to signal handlers, particularly whether + * si_addr is filled in properly, and whether the segfault handler is called + * quickly enough. */ + void SEGVHandler::test_handler(int signum, siginfo_t *info, void *context) + { + SEGVHandler &that = ElfLoader::Singleton; +- if (signum != SIGSEGV || +- info == nullptr || info->si_addr != that.stackPtr.get()) +- that.signalHandlingBroken = true; ++ if (signum == SIGSEGV && info && ++ info->si_addr == that.stackPtr.get()) ++ that.signalHandlingBroken = false; + mprotect(that.stackPtr, that.stackPtr.GetLength(), PROT_READ | PROT_WRITE); + TmpData *data = reinterpret_cast<TmpData*>(that.stackPtr.get()); + uint64_t latency = ProcessTimeStamp_Now() - data->crash_timestamp; + DEBUG_LOG("SEGVHandler latency: %" PRIu64, latency); + /* See bug 886736 for timings on different devices, 150 µs is reasonably above +- * the latency on "working" devices and seems to be reasonably fast to incur +- * a huge overhead to on-demand decompression. */ +- if (latency > 150000) +- that.signalHandlingSlow = true; ++ * the latency on "working" devices and seems to be reasonably fast not to ++ * incur a huge overhead to on-demand decompression. */ ++ if (latency <= 150000) ++ that.signalHandlingSlow = false; + } + + /* TODO: "properly" handle signal masks and flags */ + void SEGVHandler::handler(int signum, siginfo_t *info, void *context) + { + //ASSERT(signum == SIGSEGV); + DEBUG_LOG("Caught segmentation fault @%p", info->si_addr); + +--- a/mozglue/linker/ElfLoader.h ++++ a/mozglue/linker/ElfLoader.h +@@ -307,32 +307,40 @@ private: + * faults within the address space of the loaded libraries. It however + * allows a handler to be set for faults in other places, and redispatches + * to the handler set through signal() or sigaction(). + */ + class SEGVHandler + { + public: + bool hasRegisteredHandler() { ++ if (! initialized) ++ FinishInitialization(); + return registeredHandler; + } + + bool isSignalHandlingBroken() { + return signalHandlingBroken; + } + + protected: + SEGVHandler(); + ~SEGVHandler(); + + private: + static int __wrap_sigaction(int signum, const struct sigaction *act, + struct sigaction *oldact); + + /** ++ * The constructor doesn't do all initialization, and the tail is done ++ * at a later time. ++ */ ++ void FinishInitialization(); ++ ++ /** + * SIGSEGV handler registered with __wrap_signal or __wrap_sigaction. + */ + struct sigaction action; + + /** + * ElfLoader SIGSEGV handler. + */ + static void handler(int signum, siginfo_t *info, void *context); +@@ -354,16 +362,17 @@ private: + stack_t oldStack; + + /** + * Pointer to an alternative stack for signals. Only set if oldStack is + * not set or not big enough. + */ + MappedPtr stackPtr; + ++ bool initialized; + bool registeredHandler; + bool signalHandlingBroken; + bool signalHandlingSlow; + }; + + /** + * Elf Loader class in charge of loading and bookkeeping libraries. + */ diff --git a/data/patches/gnuzilla-bug-1036286-2.patch b/data/patches/gnuzilla-bug-1036286-2.patch new file mode 100644 index 0000000..6708062 --- /dev/null +++ b/data/patches/gnuzilla-bug-1036286-2.patch @@ -0,0 +1,105 @@ +--- a/mozglue/linker/CustomElf.cpp ++++ a/mozglue/linker/CustomElf.cpp +@@ -1,16 +1,17 @@ + /* 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 <cstring> + #include <sys/mman.h> + #include <vector> + #include <dlfcn.h> ++#include <signal.h> + #include "CustomElf.h" + #include "Mappable.h" + #include "Logging.h" + + using namespace Elf; + using namespace mozilla; + + /* TODO: Fill ElfLoader::Singleton.lastError on errors. */ +@@ -348,16 +349,21 @@ CustomElf::GetSymbolPtrInDeps(const char + if (strcmp(symbol + 2, "dso_handle") == 0) + return const_cast<CustomElf *>(this); + if (strcmp(symbol + 2, "moz_linker_stats") == 0) + return FunctionPtr(&ElfLoader::stats); + #ifdef __ARM_EABI__ + if (strcmp(symbol + 2, "gnu_Unwind_Find_exidx") == 0) + return FunctionPtr(__wrap___gnu_Unwind_Find_exidx); + #endif ++ } else if (symbol[0] == 's' && symbol[1] == 'i') { ++ if (strcmp(symbol + 2, "gnal") == 0) ++ return FunctionPtr(signal); ++ if (strcmp(symbol + 2, "gaction") == 0) ++ return FunctionPtr(sigaction); + } + + #define MISSING_FLASH_SYMNAME_START "_ZN7android10VectorImpl19reservedVectorImpl" + + // Android changed some symbols that Flash depended on in 4.4, + // so stub those out here + if (strncmp(symbol, + MISSING_FLASH_SYMNAME_START, +--- a/mozglue/linker/ElfLoader.cpp ++++ a/mozglue/linker/ElfLoader.cpp +@@ -1014,17 +1014,59 @@ SEGVHandler::FinishInitialization() + { + /* Ideally, we'd need some locking here, but in practice, we're not + * going to race with another thread. */ + initialized = true; + + if (signalHandlingBroken || signalHandlingSlow) + return; + +- if (!Divert(sigaction, __wrap_sigaction)) ++ typedef int (*sigaction_func)(int, const struct sigaction *, ++ struct sigaction *); ++ ++ sigaction_func libc_sigaction; ++ ++#if defined(ANDROID) ++ /* Android > 4.4 comes with a sigaction wrapper in a LD_PRELOADed library ++ * (libsigchain) for ART. That wrapper kind of does the same trick as we ++ * do, so we need extra care in handling it. ++ * - Divert the libc's sigaction, assuming the LD_PRELOADed library uses ++ * it under the hood (which is more or less true according to the source ++ * of that library, since it's doing a lookup in RTLD_NEXT) ++ * - With the LD_PRELOADed library in place, all calls to sigaction from ++ * from system libraries will go to the LD_PRELOADed library. ++ * - The LD_PRELOADed library calls to sigaction go to our __wrap_sigaction. ++ * - The calls to sigaction from libraries faulty.lib loads are sent to ++ * the LD_PRELOADed library. ++ * In practice, for signal handling, this means: ++ * - The signal handler registered to the kernel is ours. ++ * - Our handler redispatches to the LD_PRELOADed library's if there's a ++ * segfault we don't handle. ++ * - The LD_PRELOADed library redispatches according to whatever system ++ * library or faulty.lib-loaded library set with sigaction. ++ * ++ * When there is no sigaction wrapper in place: ++ * - Divert the libc's sigaction. ++ * - Calls to sigaction from system library and faulty.lib-loaded libraries ++ * all go to the libc's sigaction, which end up in our __wrap_sigaction. ++ * - The signal handler registered to the kernel is ours. ++ * - Our handler redispatches according to whatever system library or ++ * faulty.lib-loaded library set with sigaction. ++ */ ++ void *libc = dlopen("libc.so", RTLD_GLOBAL | RTLD_LAZY); ++ if (libc) { ++ libc_sigaction = ++ reinterpret_cast<sigaction_func>(dlsym(libc, "sigaction")); ++ } else ++#endif ++ { ++ libc_sigaction = sigaction; ++ } ++ ++ if (!Divert(libc_sigaction, __wrap_sigaction)) + return; + + /* Setup an alternative stack if the already existing one is not big + * enough, or if there is none. */ + if (sigaltstack(nullptr, &oldStack) == 0) { + if (oldStack.ss_flags == SS_ONSTACK) + oldStack.ss_flags = 0; + if (!oldStack.ss_sp || oldStack.ss_size < stackSize) { diff --git a/data/patches/gnuzilla-bug-1050780.patch b/data/patches/gnuzilla-bug-1050780.patch new file mode 100644 index 0000000..b142dc7 --- /dev/null +++ b/data/patches/gnuzilla-bug-1050780.patch @@ -0,0 +1,53 @@ +# HG changeset patch +# User Lucas Rocha <lucasr@mozilla.com> + +Bug 1050780 - Avoid disabled items in GeckoMenu's adapter (r=margaret) + +diff --git a/mobile/android/base/menu/GeckoMenu.java b/mobile/android/base/menu/GeckoMenu.java +index eff2a51..cd2404b 100644 +--- a/mobile/android/base/menu/GeckoMenu.java ++++ b/mobile/android/base/menu/GeckoMenu.java +@@ -781,17 +781,19 @@ public class GeckoMenu extends ListView + public boolean areAllItemsEnabled() { + // Setting this to true is a workaround to fix disappearing + // dividers in the menu (bug 963249). + return true; + } + + @Override + public boolean isEnabled(int position) { +- return getItem(position).isEnabled(); ++ // Setting this to true is a workaround to fix disappearing ++ // dividers in the menu in L (bug 1050780). ++ return true; + } + + public void addMenuItem(GeckoMenuItem menuItem) { + if (mItems.contains(menuItem)) + return; + + // Insert it in proper order. + int index = 0; +diff --git a/mobile/android/base/resources/drawable/action_bar_button.xml b/mobile/android/base/resources/drawable/action_bar_button.xml +index 9cb7aa8..fe36bc4 100644 +--- a/mobile/android/base/resources/drawable/action_bar_button.xml ++++ b/mobile/android/base/resources/drawable/action_bar_button.xml +@@ -1,16 +1,17 @@ + <?xml version="1.0" encoding="utf-8"?> + <!-- 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/. --> + + <selector xmlns:android="http://schemas.android.com/apk/res/android"> + +- <item android:state_pressed="true"> ++ <item android:state_pressed="true" ++ android:state_enabled="true"> + <shape> + <solid android:color="@color/highlight" /> + </shape> + </item> + + <item android:state_focused="true" + android:state_pressed="false"> + <shape> diff --git a/data/patches/gnuzilla-bug-1055166.patch b/data/patches/gnuzilla-bug-1055166.patch new file mode 100644 index 0000000..51b8ee5 --- /dev/null +++ b/data/patches/gnuzilla-bug-1055166.patch @@ -0,0 +1,33 @@ +From: James Willcox <snorp@snorp.net> +Bug 1055166 - Catch IllegalStateException when recycling Message + + + +diff --git a/mobile/android/base/GeckoAppShell.java b/mobile/android/base/GeckoAppShell.java +index b06547f8c8135542d27713bb8e4c5d0e7496bb17..a50538e1b3449d3767ad78ed3fb8e596bc1acfbb 100644 +--- a/mobile/android/base/GeckoAppShell.java ++++ b/mobile/android/base/GeckoAppShell.java +@@ -2478,17 +2478,22 @@ public class GeckoAppShell + // Our "queue is empty" message; see runGecko() + msg.recycle(); + return false; + } + if (msg.getTarget() == null) + Looper.myLooper().quit(); + else + msg.getTarget().dispatchMessage(msg); +- msg.recycle(); ++ ++ try { ++ msg.recycle(); ++ } catch (IllegalStateException e) { ++ // There is nothing we can do here so just eat it ++ } + return true; + } + + @WrapElementForJNI + public static void notifyWakeLockChanged(String topic, String state) { + if (getGeckoInterface() != null) + getGeckoInterface().notifyWakeLockChanged(topic, state); + } diff --git a/data/patches/gnuzilla-bug-1058778.patch b/data/patches/gnuzilla-bug-1058778.patch new file mode 100644 index 0000000..27d5097 --- /dev/null +++ b/data/patches/gnuzilla-bug-1058778.patch @@ -0,0 +1,10 @@ +--- a/security/build/moz.build 2015-01-06 05:07:59.000000000 +0000 ++++ b/security/build/moz.build 2015-01-30 21:55:40.988341831 +0000 +@@ -10,5 +10,5 @@ + + FORCE_SHARED_LIB = True + +-if CONFIG['OS_TARGET'] == 'WINNT': +- DEFFILE = 'nss3.def' ++ if CONFIG['OS_TARGET'] == 'WINNT': ++ DEFFILE = 'nss3.def' diff --git a/data/patches/gnuzilla-bug-1089931.patch b/data/patches/gnuzilla-bug-1089931.patch new file mode 100644 index 0000000..cfd019f --- /dev/null +++ b/data/patches/gnuzilla-bug-1089931.patch @@ -0,0 +1,40 @@ +https://bugzilla.mozilla.org/show_bug.cgi?id=1089931 +--- a/toolkit/crashreporter/google-breakpad/src/common/android/include/ucontext.h ++++ a/toolkit/crashreporter/google-breakpad/src/common/android/include/ucontext.h +@@ -26,31 +26,30 @@ + // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + #ifndef GOOGLE_BREAKPAD_COMMON_ANDROID_INCLUDE_UCONTEXT_H + #define GOOGLE_BREAKPAD_COMMON_ANDROID_INCLUDE_UCONTEXT_H + + #include <sys/cdefs.h> ++#include <signal.h> + +-#ifdef __BIONIC_UCONTEXT_H +-#include <ucontext.h> ++#ifdef __BIONIC_HAVE_UCONTEXT_H ++# include_next <ucontext.h> + #else +- +-#include <sys/ucontext.h> ++# include <sys/ucontext.h> ++#endif // __BIONIC_UCONTEXT_H + + #ifdef __cplusplus + extern "C" { + #endif // __cplusplus + + // Provided by src/android/common/breakpad_getcontext.S + int breakpad_getcontext(ucontext_t* ucp); + + #define getcontext(x) breakpad_getcontext(x) + + #ifdef __cplusplus + } // extern "C" + #endif // __cplusplus + +-#endif // __BIONIC_UCONTEXT_H +- + #endif // GOOGLE_BREAKPAD_COMMON_ANDROID_INCLUDE_UCONTEXT_H diff --git a/data/patches/gnuzilla-bug-1091987.patch b/data/patches/gnuzilla-bug-1091987.patch new file mode 100644 index 0000000..d42b5df --- /dev/null +++ b/data/patches/gnuzilla-bug-1091987.patch @@ -0,0 +1,40 @@ +https://bugzilla.mozilla.org/show_bug.cgi?id=1091987 + +--- a/widget/android/AndroidJavaWrappers.h ++++ a/widget/android/AndroidJavaWrappers.h +@@ -228,16 +228,17 @@ private: + static jmethodID jBeginDrawingMethod; + static jmethodID jDrawBackgroundMethod; + static jmethodID jDrawForegroundMethod; + static jmethodID jEndDrawingMethod; + }; + + enum { + // These keycode masks are not defined in android/keycodes.h: ++#if __ANDROID_API__ < 15 + AKEYCODE_ESCAPE = 111, + AKEYCODE_FORWARD_DEL = 112, + AKEYCODE_CTRL_LEFT = 113, + AKEYCODE_CTRL_RIGHT = 114, + AKEYCODE_CAPS_LOCK = 115, + AKEYCODE_SCROLL_LOCK = 116, + AKEYCODE_META_LEFT = 117, + AKEYCODE_META_RIGHT = 118, +@@ -337,16 +338,17 @@ enum { + AKEYCODE_EISU = 212, + AKEYCODE_MUHENKAN = 213, + AKEYCODE_HENKAN = 214, + AKEYCODE_KATAKANA_HIRAGANA = 215, + AKEYCODE_YEN = 216, + AKEYCODE_RO = 217, + AKEYCODE_KANA = 218, + AKEYCODE_ASSIST = 219, ++#endif + + AMETA_FUNCTION_ON = 0x00000008, + AMETA_CTRL_ON = 0x00001000, + AMETA_CTRL_LEFT_ON = 0x00002000, + AMETA_CTRL_RIGHT_ON = 0x00004000, + AMETA_META_ON = 0x00010000, + AMETA_META_LEFT_ON = 0x00020000, + AMETA_META_RIGHT_ON = 0x00040000, diff --git a/data/patches/gnuzilla-bug-1095298.patch b/data/patches/gnuzilla-bug-1095298.patch new file mode 100644 index 0000000..aa075a2 --- /dev/null +++ b/data/patches/gnuzilla-bug-1095298.patch @@ -0,0 +1,30 @@ +--- a/intl/locale/src/nsLocaleService.cpp ++++ a/intl/locale/src/nsLocaleService.cpp +@@ -135,17 +135,25 @@ nsLocaleService::nsLocaleService(void) + + for( i = 0; i < LocaleListLength; i++ ) { + nsresult result; + // setlocale( , "") evaluates LC_* and LANG + char* lc_temp = setlocale(posix_locale_category[i], ""); + CopyASCIItoUTF16(LocaleList[i], category); + category_platform = category; + category_platform.AppendLiteral("##PLATFORM"); +- if (lc_temp != nullptr) { ++ ++ bool lc_temp_valid = lc_temp != nullptr; ++ ++#if defined(MOZ_WIDGET_ANDROID) ++ // Treat the "C" env as nothing useful. See Bug 1095298. ++ lc_temp_valid = lc_temp_valid && strcmp(lc_temp, "C") != 0; ++#endif ++ ++ if (lc_temp_valid) { + result = nsPosixLocale::GetXPLocale(lc_temp, xpLocale); + CopyASCIItoUTF16(lc_temp, platformLocale); + } else { + if ( lang == nullptr ) { + platformLocale.AssignLiteral("en_US"); + result = nsPosixLocale::GetXPLocale("en-US", xpLocale); + } else { + CopyASCIItoUTF16(lang, platformLocale); + diff --git a/data/patches/reduceGeckoPriority.patch b/data/patches/reduceGeckoPriority.patch new file mode 100644 index 0000000..843d2c8 --- /dev/null +++ b/data/patches/reduceGeckoPriority.patch @@ -0,0 +1,18 @@ +diff -ur icecat-31.4.0.orig/mobile/android/base/util/ThreadUtils.java icecat-31.4.0/mobile/android/base/util/ThreadUtils.java +--- icecat-31.4.0.orig/mobile/android/base/util/ThreadUtils.java 2015-02-22 18:35:21.022789023 +0000 ++++ icecat-31.4.0/mobile/android/base/util/ThreadUtils.java 2015-02-22 22:09:50.518544343 +0000 +@@ -179,7 +179,13 @@ + * @param timeout Timeout in ms after which the priority will be reset + */ + public static void reduceGeckoPriority(long timeout) { +- if (!sIsGeckoPriorityReduced) { ++ if (Runtime.getRuntime().availableProcessors() > 1) { ++ // Don't reduce priority for multicore devices. We use availableProcessors() ++ // for its fast performance. It may give false negatives (i.e. multicore ++ // detected as single-core), but we can tolerate this behavior. ++ return; ++ } ++ if (!sIsGeckoPriorityReduced && sGeckoThread != null) { + sIsGeckoPriorityReduced = true; + sGeckoThread.setPriority(Thread.MIN_PRIORITY); + getUiHandler().postDelayed(sPriorityResetRunnable, timeout); diff --git a/data/patches/reorder-mobile_android_base_android-services_mozbuild.patch b/data/patches/reorder-mobile_android_base_android-services_mozbuild.patch new file mode 100644 index 0000000..dd38815 --- /dev/null +++ b/data/patches/reorder-mobile_android_base_android-services_mozbuild.patch @@ -0,0 +1,34 @@ +--- a/mobile/android/base/android-services.mozbuild 2015-01-06 05:07:54.000000000 +0000 ++++ b/mobile/android/base/android-services.mozbuild 2015-02-02 02:59:30.180709918 +0000 +@@ -567,7 +567,7 @@ + 'fxa/authenticator/FxAccountAuthenticatorService.java', + 'fxa/authenticator/FxAccountLoginDelegate.java', + 'fxa/authenticator/FxAccountLoginException.java', +- 'fxa/FirefoxAccounts.java', ++ 'fxa/IceCatAccounts.java', + 'fxa/login/BaseRequestDelegate.java', + 'fxa/login/Cohabiting.java', + 'fxa/login/Doghouse.java', +@@ -709,8 +709,8 @@ + 'sync/repositories/android/CachedSQLiteOpenHelper.java', + 'sync/repositories/android/ClientsDatabase.java', + 'sync/repositories/android/ClientsDatabaseAccessor.java', +- 'sync/repositories/android/FennecTabsRepository.java', + 'sync/repositories/android/FormHistoryRepositorySession.java', ++ 'sync/repositories/android/IceCatMobileTabsRepository.java', + 'sync/repositories/android/PasswordsRepositorySession.java', + 'sync/repositories/android/RepoUtils.java', + 'sync/repositories/BookmarkNeedsReparentingException.java', +@@ -803,11 +803,11 @@ + 'sync/stage/CompletedStage.java', + 'sync/stage/EnsureClusterURLStage.java', + 'sync/stage/EnsureCrypto5KeysStage.java', +- 'sync/stage/FennecTabsServerSyncStage.java', + 'sync/stage/FetchInfoCollectionsStage.java', + 'sync/stage/FetchMetaGlobalStage.java', + 'sync/stage/FormHistoryServerSyncStage.java', + 'sync/stage/GlobalSyncStage.java', ++ 'sync/stage/IceCatMobileTabsServerSyncStage.java', + 'sync/stage/NoSuchStageException.java', + 'sync/stage/NoSyncIDException.java', + 'sync/stage/PasswordsServerSyncStage.java', diff --git a/data/patches/revert-gnuzilla-bug-973138.patch b/data/patches/revert-gnuzilla-bug-973138.patch new file mode 100644 index 0000000..ffd3a68 --- /dev/null +++ b/data/patches/revert-gnuzilla-bug-973138.patch @@ -0,0 +1,25 @@ +This patch reverts fix for gnuzilla bug: +https://bugzilla.mozilla.org/show_bug.cgi?id=973138 +which introduces: +https://trac.torproject.org/projects/tor/ticket/12811 +https://bugzilla.mozilla.org/show_bug.cgi?id=1049366 + +--- a/mozglue/build/WindowsDllBlocklist.cpp 2015-01-27 19:17:08.585519129 +0100 ++++ b/mozglue/build/WindowsDllBlocklist.cpp 2015-01-30 00:42:10.817863012 +0100 +@@ -551,7 +551,7 @@ + printf_stderr("LdrLoadDll: dll name '%s'\n", dllName); + #endif + +- // Block a suspicious binary that uses various 12-digit hex strings ++/* // Block a suspicious binary that uses various 12-digit hex strings + // e.g. MovieMode.48CA2AEFA22D.dll (bug 973138) + char * dot = strchr(dllName, '.'); + if (dot && (strchr(dot+1, '.') == dot+13)) { +@@ -561,6 +561,7 @@ + return STATUS_DLL_NOT_FOUND; + } + } ++*/ + + // then compare to everything on the blocklist + info = &sWindowsDllBlocklist[0]; diff --git a/data/patches/torbrowser-bug-12811-2.patch b/data/patches/torbrowser-bug-12811-2.patch new file mode 100644 index 0000000..e80e228 --- /dev/null +++ b/data/patches/torbrowser-bug-12811-2.patch @@ -0,0 +1,33 @@ +commit 73a628a5cebfa6dae1fca4c5fde072376ce4d06f +Author: Georg Koppen <gk at torproject.org> +Date: Fri Sep 12 09:37:39 2014 +0000 + + Bug 12811: Add MOZ_D3DCOMPILER_DLL iff available. + + It seems MOZ_D3DCOMPILER_DLL is not avilable when compiling with + mingw-w64. Trying to include it nevertheless breaks the packaging step + as `@BINPATH@/@MOZ_D3DCOMPILER_DLL@` resolves to `bin/` which results + in including all the things beginning with a `bin/` (again) which is + treated as an error in case they got already included. + + This got fixed more or less by accident by bug 999260 which did not make + it into ESR 31 (https://hg.mozilla.org/mozilla-central/rev/8b48386fc226). +--- + browser/installer/package-manifest.in | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/browser/installer/package-manifest.in b/browser/installer/package-manifest.in +index 521538f..c9117cf 100644 +--- a/browser/installer/package-manifest.in ++++ b/browser/installer/package-manifest.in +@@ -597,8 +597,10 @@ + #ifdef MOZ_ANGLE_RENDERER + @BINPATH@/libEGL.dll + @BINPATH@/libGLESv2.dll ++#ifdef MOZ_D3DCOMPILER_DLL_PATH + @BINPATH@/@MOZ_D3DCOMPILER_DLL@ + #endif ++#endif + + ; [Browser Chrome Files] + @BINPATH@/browser/chrome.manifest diff --git a/data/patches/torbrowser-bug-12811.patch b/data/patches/torbrowser-bug-12811.patch new file mode 100644 index 0000000..6b062f4 --- /dev/null +++ b/data/patches/torbrowser-bug-12811.patch @@ -0,0 +1,19 @@ + Bug 12811: WTypes.h -> wtypes.h +--- + .../google-breakpad/src/google_breakpad/common/breakpad_types.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/toolkit/crashreporter/google-breakpad/src/google_breakpad/common/breakpad_types.h b/toolkit/crashreporter/google-breakpad/src/google_breakpad/common/breakpad_types.h +index a60c5f3..e92436f 100644 +--- a/toolkit/crashreporter/google-breakpad/src/google_breakpad/common/breakpad_types.h ++++ b/toolkit/crashreporter/google-breakpad/src/google_breakpad/common/breakpad_types.h +@@ -58,7 +58,7 @@ + */ + #include BREAKPAD_CUSTOM_STDINT_H + #else +-#include <WTypes.h> ++#include <wtypes.h> + + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + diff --git a/data/patches/torbrowser-bug-9837.patch b/data/patches/torbrowser-bug-9837.patch new file mode 100644 index 0000000..f62f0cb --- /dev/null +++ b/data/patches/torbrowser-bug-9837.patch @@ -0,0 +1,22 @@ + Disable uninstall helper.exe on Win32. + + Reworked for Icecat + + Fixes 'make package' breakage on Windows builds. See + https://trac.torproject.org/projects/tor/ticket/9837 +--- + browser/installer/package-manifest.in | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/browser/installer/package-manifest.in 2015-01-30 23:33:42.296298458 +0100 ++++ b/browser/installer/package-manifest.in 2015-02-02 03:22:28.480752158 +0100 +@@ -43,7 +43,7 @@ + @BINPATH@/browser/@PREF_DIR@/firefox-l10n.js + @BINPATH@/browser/searchplugins/* + #ifdef XP_WIN32 +-@BINPATH@/uninstall/helper.exe ++;@BINPATH@/uninstall/helper.exe + #endif + #ifdef MOZ_UPDATER + @BINPATH@/update.locale + |