Bug 1266235 - Use blocklist prefix in preference names. r=MattN
authorMathieu Leplatre <mathieu@mozilla.com>
Thu, 19 May 2016 12:51:13 +0200
changeset 298926 c6c57d3945491d0c15914c3212f7162e772e6904
parent 298925 dc96a1440e3c4f29da67e6eb8b6b6004a021bc7f
child 298927 a5aad78f70ea5c1122f64825b489f8b2ea570ac5
push id77374
push usercbook@mozilla.com
push dateWed, 25 May 2016 13:20:27 +0000
treeherdermozilla-inbound@0bc5c825c58e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersMattN
bugs1266235
milestone49.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1266235 - Use blocklist prefix in preference names. r=MattN MozReview-Commit-ID: 5aeoiSEMwYw
addon-sdk/source/test/preferences/no-connections.json
browser/app/profile/firefox.js
browser/base/content/content.js
browser/base/content/test/general/browser_aboutCertError.js
mobile/android/app/mobile.js
security/manager/ssl/CertBlocklist.cpp
security/manager/ssl/tests/unit/test_cert_blocklist.js
security/manager/ssl/tests/unit/test_ev_certs.js
services/common/blocklist-clients.js
services/common/blocklist-updater.js
services/common/tests/unit/test_blocklist_certificates.js
services/common/tests/unit/test_blocklist_clients.js
services/common/tests/unit/test_blocklist_updater.js
services/common/tests/unit/test_kinto.js
testing/profiles/prefs_general.js
toolkit/mozapps/extensions/nsBlocklistService.js
toolkit/mozapps/extensions/test/xpcshell/head_addons.js
toolkit/mozapps/extensions/test/xpcshell/test_blocklist_regexp.js
--- a/addon-sdk/source/test/preferences/no-connections.json
+++ b/addon-sdk/source/test/preferences/no-connections.json
@@ -23,17 +23,17 @@
   "browser.safebrowsing.provider.mozilla.updateURL": "http://localhost/safebrowsing-dummy/update",
   "browser.newtabpage.directory.source": "data:application/json,{'jetpack':1}",
   "browser.newtabpage.directory.ping": "",
   "extensions.update.url": "http://localhost/extensions-dummy/updateURL",
   "extensions.update.background.url": "http://localhost/extensions-dummy/updateBackgroundURL",
   "extensions.blocklist.url": "http://localhost/extensions-dummy/blocklistURL",
   "extensions.webservice.discoverURL": "http://localhost/extensions-dummy/discoveryURL",
   "extensions.getAddons.maxResults": 0,
-  "services.kinto.base": "http://localhost/dummy-kinto/v1",
+  "services.blocklist.base": "http://localhost/dummy-kinto/v1",
   "geo.wifi.uri": "http://localhost/location-dummy/locationURL",
   "browser.search.geoip.url": "http://localhost/location-dummy/locationURL",
   "browser.search.isUS": true,
   "browser.search.countryCode": "US",
   "geo.wifi.uri": "http://localhost/extensions-dummy/geowifiURL",
   "geo.wifi.scan": false,
   "browser.webapps.checkForUpdates": 0,
   "identity.fxaccounts.auth.uri": "http://localhost/fxa-dummy/"
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -57,34 +57,34 @@ pref("extensions.blocklist.enabled", tru
 pref("extensions.blocklist.interval", 86400);
 // Controls what level the blocklist switches from warning about items to forcibly
 // blocking them.
 pref("extensions.blocklist.level", 2);
 pref("extensions.blocklist.url", "https://blocklist.addons.mozilla.org/blocklist/3/%APP_ID%/%APP_VERSION%/%PRODUCT%/%BUILD_ID%/%BUILD_TARGET%/%LOCALE%/%CHANNEL%/%OS_VERSION%/%DISTRIBUTION%/%DISTRIBUTION_VERSION%/%PING_COUNT%/%TOTAL_PING_COUNT%/%DAYS_SINCE_LAST_PING%/");
 pref("extensions.blocklist.detailsURL", "https://www.mozilla.org/%LOCALE%/blocklist/");
 pref("extensions.blocklist.itemURL", "https://blocklist.addons.mozilla.org/%LOCALE%/%APP%/blocked/%blockID%");
 
-// Kinto blocklist preferences
-pref("services.kinto.base", "https://firefox.settings.services.mozilla.com/v1");
-pref("services.kinto.changes.path", "/buckets/monitor/collections/changes/records");
-pref("services.kinto.bucket", "blocklists");
-pref("services.kinto.onecrl.collection", "certificates");
-pref("services.kinto.onecrl.checked", 0);
-pref("services.kinto.addons.collection", "addons");
-pref("services.kinto.addons.checked", 0);
-pref("services.kinto.plugins.collection", "plugins");
-pref("services.kinto.plugins.checked", 0);
-pref("services.kinto.gfx.collection", "gfx");
-pref("services.kinto.gfx.checked", 0);
+// Blocklist preferences
+pref("services.settings.server", "https://firefox.settings.services.mozilla.com/v1");
+pref("services.blocklist.changes.path", "/buckets/monitor/collections/changes/records");
+pref("services.blocklist.bucket", "blocklists");
+pref("services.blocklist.onecrl.collection", "certificates");
+pref("services.blocklist.onecrl.checked", 0);
+pref("services.blocklist.addons.collection", "addons");
+pref("services.blocklist.addons.checked", 0);
+pref("services.blocklist.plugins.collection", "plugins");
+pref("services.blocklist.plugins.checked", 0);
+pref("services.blocklist.gfx.collection", "gfx");
+pref("services.blocklist.gfx.checked", 0);
 
 // for now, let's keep kinto update out of the release channel
 #ifdef RELEASE_BUILD
-pref("services.kinto.update_enabled", false);
+pref("services.blocklist.update_enabled", false);
 #else
-pref("services.kinto.update_enabled", true);
+pref("services.blocklist.update_enabled", true);
 #endif
 
 pref("extensions.update.autoUpdateDefault", true);
 
 pref("extensions.hotfix.id", "firefox-hotfix@mozilla.org");
 pref("extensions.hotfix.cert.checkAttributes", true);
 pref("extensions.hotfix.certs.1.sha1Fingerprint", "91:53:98:0C:C1:86:DF:47:8F:35:22:9E:11:C9:A7:31:04:49:A1:AA");
 pref("extensions.hotfix.certs.2.sha1Fingerprint", "39:E7:2B:7A:5B:CF:37:78:F9:5D:4A:E0:53:2D:2F:3D:68:53:C5:60");
--- a/browser/base/content/content.js
+++ b/browser/base/content/content.js
@@ -226,17 +226,17 @@ const MOZILLA_PKIX_ERROR_BASE = Ci.nsINS
 
 const SEC_ERROR_EXPIRED_CERTIFICATE                = SEC_ERROR_BASE + 11;
 const SEC_ERROR_UNKNOWN_ISSUER                     = SEC_ERROR_BASE + 13;
 const SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE         = SEC_ERROR_BASE + 30;
 const SEC_ERROR_OCSP_FUTURE_RESPONSE               = SEC_ERROR_BASE + 131;
 const SEC_ERROR_OCSP_OLD_RESPONSE                  = SEC_ERROR_BASE + 132;
 const MOZILLA_PKIX_ERROR_NOT_YET_VALID_CERTIFICATE = MOZILLA_PKIX_ERROR_BASE + 5;
 
-const PREF_KINTO_CLOCK_SKEW_SECONDS = "services.kinto.clock_skew_seconds";
+const PREF_BLOCKLIST_CLOCK_SKEW_SECONDS = "services.blocklist.clock_skew_seconds";
 
 const PREF_SSL_IMPACT_ROOTS = ["security.tls.version.min", "security.tls.version.max", "security.ssl3."];
 
 const PREF_SSL_IMPACT = PREF_SSL_IMPACT_ROOTS.reduce((prefs, root) => {
   return prefs.concat(Services.prefs.getChildList(root));
 }, []);
 
 
@@ -275,26 +275,26 @@ var AboutNetAndCertErrorListener = {
 
     switch (msg.data.code) {
       case SEC_ERROR_UNKNOWN_ISSUER:
         let learnMoreLink = content.document.getElementById("learnMoreLink");
         learnMoreLink.href = "https://support.mozilla.org/kb/troubleshoot-SEC_ERROR_UNKNOWN_ISSUER";
         break;
 
       // in case the certificate expired we make sure the system clock
-      // matches kinto server time
+      // matches settings server (kinto) time
       case SEC_ERROR_EXPIRED_CERTIFICATE:
       case SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE:
       case SEC_ERROR_OCSP_FUTURE_RESPONSE:
       case SEC_ERROR_OCSP_OLD_RESPONSE:
       case MOZILLA_PKIX_ERROR_NOT_YET_VALID_CERTIFICATE:
 
-        // use Kinto stats if available
-        if (Services.prefs.getPrefType(PREF_KINTO_CLOCK_SKEW_SECONDS)) {
-          let difference = Services.prefs.getIntPref(PREF_KINTO_CLOCK_SKEW_SECONDS);
+        // use blocklist stats if available
+        if (Services.prefs.getPrefType(PREF_BLOCKLIST_CLOCK_SKEW_SECONDS)) {
+          let difference = Services.prefs.getIntPref(PREF_BLOCKLIST_CLOCK_SKEW_SECONDS);
 
           // if the difference is more than a day
           if (Math.abs(difference) > 60 * 60 * 24) {
             let formatter = new Intl.DateTimeFormat();
             let systemDate = formatter.format(new Date());
             // negative difference means local time is behind server time
             let actualDate = formatter.format(new Date(Date.now() - difference * 1000));
 
--- a/browser/base/content/test/general/browser_aboutCertError.js
+++ b/browser/base/content/test/general/browser_aboutCertError.js
@@ -100,17 +100,17 @@ add_task(function* checkBadStsCert() {
     let exceptionButton = doc.getElementById("exceptionDialogButton");
     return exceptionButton.hidden;
   });
   ok(exceptionButtonHidden, "Exception button is hidden");
 
   yield BrowserTestUtils.removeTab(gBrowser.selectedTab);
 });
 
-const PREF_KINTO_CLOCK_SKEW_SECONDS = "services.kinto.clock_skew_seconds";
+const PREF_BLOCKLIST_CLOCK_SKEW_SECONDS = "services.blocklist.clock_skew_seconds";
 
 add_task(function* checkWrongSystemTimeWarning() {
   function* setUpPage() {
     let browser;
     let certErrorLoaded;
     let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, () => {
       gBrowser.selectedTab = gBrowser.addTab(BAD_CERT);
       browser = gBrowser.selectedBrowser;
@@ -139,17 +139,17 @@ add_task(function* checkWrongSystemTimeW
 
   // pretend we have a positively skewed (ahead) system time
   let serverDate = new Date("2015/10/27");
   let serverDateFmt = formatter.format(serverDate);
   let localDateFmt = formatter.format(new Date());
 
   let skew = Math.floor((Date.now() - serverDate.getTime()) / 1000);
   yield new Promise(r => SpecialPowers.pushPrefEnv({set:
-    [[PREF_KINTO_CLOCK_SKEW_SECONDS, skew]]}, r));
+    [[PREF_BLOCKLIST_CLOCK_SKEW_SECONDS, skew]]}, r));
 
   info("Loading a bad cert page with a skewed clock");
   let message = yield Task.spawn(setUpPage);
 
   isnot(message.divDisplay, "none", "Wrong time message information is visible");
   ok(message.text.includes("because your clock appears to show the wrong time"),
      "Correct error message found");
   ok(message.text.includes("expired.example.com"), "URL found in error message");
@@ -160,46 +160,46 @@ add_task(function* checkWrongSystemTimeW
 
   // pretend we have a negatively skewed (behind) system time
   serverDate = new Date();
   serverDate.setYear(serverDate.getFullYear() + 1);
   serverDateFmt = formatter.format(serverDate);
 
   skew = Math.floor((Date.now() - serverDate.getTime()) / 1000);
   yield new Promise(r => SpecialPowers.pushPrefEnv({set:
-    [[PREF_KINTO_CLOCK_SKEW_SECONDS, skew]]}, r));
+    [[PREF_BLOCKLIST_CLOCK_SKEW_SECONDS, skew]]}, r));
 
   info("Loading a bad cert page with a skewed clock");
   message = yield Task.spawn(setUpPage);
 
   isnot(message.divDisplay, "none", "Wrong time message information is visible");
   ok(message.text.includes("because your clock appears to show the wrong time"),
      "Correct error message found");
   ok(message.text.includes("expired.example.com"), "URL found in error message");
   ok(message.systemDate.includes(localDateFmt), "correct local date displayed");
   ok(message.actualDate.includes(serverDateFmt), "correct server date displayed");
 
   yield BrowserTestUtils.removeTab(gBrowser.selectedTab);
 
   // pretend we only have a slightly skewed system time, four hours
   skew = 60 * 60 * 4;
   yield new Promise(r => SpecialPowers.pushPrefEnv({set:
-    [[PREF_KINTO_CLOCK_SKEW_SECONDS, skew]]}, r));
+    [[PREF_BLOCKLIST_CLOCK_SKEW_SECONDS, skew]]}, r));
 
   info("Loading a bad cert page with an only slightly skewed clock");
   message = yield Task.spawn(setUpPage);
 
   is(message.divDisplay, "none", "Wrong time message information is not visible");
 
   yield BrowserTestUtils.removeTab(gBrowser.selectedTab);
 
   // now pretend we have no skewed system time
   skew = 0;
   yield new Promise(r => SpecialPowers.pushPrefEnv({set:
-    [[PREF_KINTO_CLOCK_SKEW_SECONDS, skew]]}, r));
+    [[PREF_BLOCKLIST_CLOCK_SKEW_SECONDS, skew]]}, r));
 
   info("Loading a bad cert page with no skewed clock");
   message = yield Task.spawn(setUpPage);
 
   is(message.divDisplay, "none", "Wrong time message information is not visible");
 
   yield BrowserTestUtils.removeTab(gBrowser.selectedTab);
 });
--- a/mobile/android/app/mobile.js
+++ b/mobile/android/app/mobile.js
@@ -239,35 +239,35 @@ pref("extensions.compatability.locales.b
 /* blocklist preferences */
 pref("extensions.blocklist.enabled", true);
 // OneCRL freshness checking depends on this value, so if you change it,
 // please also update security.onecrl.maximum_staleness_in_seconds.
 pref("extensions.blocklist.interval", 86400);
 pref("extensions.blocklist.url", "https://blocklist.addons.mozilla.org/blocklist/3/%APP_ID%/%APP_VERSION%/%PRODUCT%/%BUILD_ID%/%BUILD_TARGET%/%LOCALE%/%CHANNEL%/%OS_VERSION%/%DISTRIBUTION%/%DISTRIBUTION_VERSION%/%PING_COUNT%/%TOTAL_PING_COUNT%/%DAYS_SINCE_LAST_PING%/");
 pref("extensions.blocklist.detailsURL", "https://www.mozilla.com/%LOCALE%/blocklist/");
 
-// Kinto blocklist preferences
-pref("services.kinto.base", "https://firefox.settings.services.mozilla.com/v1");
-pref("services.kinto.changes.path", "/buckets/monitor/collections/changes/records");
-pref("services.kinto.bucket", "blocklists");
-pref("services.kinto.onecrl.collection", "certificates");
-pref("services.kinto.onecrl.checked", 0);
-pref("services.kinto.addons.collection", "addons");
-pref("services.kinto.addons.checked", 0);
-pref("services.kinto.plugins.collection", "plugins");
-pref("services.kinto.plugins.checked", 0);
-pref("services.kinto.gfx.collection", "gfx");
-pref("services.kinto.gfx.checked", 0);
+// Blocklist preferences
+pref("services.settings.server", "https://firefox.settings.services.mozilla.com/v1");
+pref("services.blocklist.changes.path", "/buckets/monitor/collections/changes/records");
+pref("services.blocklist.bucket", "blocklists");
+pref("services.blocklist.onecrl.collection", "certificates");
+pref("services.blocklist.onecrl.checked", 0);
+pref("services.blocklist.addons.collection", "addons");
+pref("services.blocklist.addons.checked", 0);
+pref("services.blocklist.plugins.collection", "plugins");
+pref("services.blocklist.plugins.checked", 0);
+pref("services.blocklist.gfx.collection", "gfx");
+pref("services.blocklist.gfx.checked", 0);
 
 // for now, let's keep kinto update out of the release channel (pending
 // collection signatures)
 #ifdef RELEASE_BUILD
-pref("services.kinto.update_enabled", false);
+pref("services.blocklist.update_enabled", false);
 #else
-pref("services.kinto.update_enabled", true);
+pref("services.blocklist.update_enabled", true);
 #endif
 
 /* Don't let XPIProvider install distribution add-ons; we do our own thing on mobile. */
 pref("extensions.installDistroAddons", false);
 
 // Add-on content security policies.
 pref("extensions.webextensions.base-content-security-policy", "script-src 'self' https://* moz-extension: blob: filesystem: 'unsafe-eval' 'unsafe-inline'; object-src 'self' https://* moz-extension: blob: filesystem:;");
 pref("extensions.webextensions.default-content-security-policy", "script-src 'self'; object-src 'self';");
--- a/security/manager/ssl/CertBlocklist.cpp
+++ b/security/manager/ssl/CertBlocklist.cpp
@@ -27,17 +27,17 @@
 #include "prtime.h"
 
 NS_IMPL_ISUPPORTS(CertBlocklist, nsICertBlocklist)
 
 using namespace mozilla;
 using namespace mozilla::pkix;
 
 #define PREF_BACKGROUND_UPDATE_TIMER "app.update.lastUpdateTime.blocklist-background-update-timer"
-#define PREF_KINTO_ONECRL_CHECKED "services.kinto.onecrl.checked"
+#define PREF_BLOCKLIST_ONECRL_CHECKED "services.blocklist.onecrl.checked"
 #define PREF_MAX_STALENESS_IN_SECONDS "security.onecrl.maximum_staleness_in_seconds"
 #define PREF_ONECRL_VIA_AMO "security.onecrl.via.amo"
 
 static LazyLogModule gCertBlockPRLog("CertBlock");
 
 uint32_t CertBlocklist::sLastBlocklistUpdate = 0U;
 uint32_t CertBlocklist::sLastKintoUpdate = 0U;
 uint32_t CertBlocklist::sMaxStaleness = 0U;
@@ -141,17 +141,17 @@ CertBlocklist::~CertBlocklist()
                                   this);
   Preferences::UnregisterCallback(CertBlocklist::PreferenceChanged,
                                   PREF_MAX_STALENESS_IN_SECONDS,
                                   this);
   Preferences::UnregisterCallback(CertBlocklist::PreferenceChanged,
                                   PREF_ONECRL_VIA_AMO,
                                   this);
   Preferences::UnregisterCallback(CertBlocklist::PreferenceChanged,
-                                  PREF_KINTO_ONECRL_CHECKED,
+                                  PREF_BLOCKLIST_ONECRL_CHECKED,
                                   this);
 }
 
 nsresult
 CertBlocklist::Init()
 {
   MOZ_LOG(gCertBlockPRLog, LogLevel::Debug, ("CertBlocklist::Init"));
 
@@ -178,17 +178,17 @@ CertBlocklist::Init()
   }
   rv = Preferences::RegisterCallbackAndCall(CertBlocklist::PreferenceChanged,
                                             PREF_ONECRL_VIA_AMO,
                                             this);
   if (NS_FAILED(rv)) {
     return rv;
   }
   rv = Preferences::RegisterCallbackAndCall(CertBlocklist::PreferenceChanged,
-                                            PREF_KINTO_ONECRL_CHECKED,
+                                            PREF_BLOCKLIST_ONECRL_CHECKED,
                                             this);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   // Get the profile directory
   rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                               getter_AddRefs(mBackingFile));
@@ -654,18 +654,18 @@ CertBlocklist::PreferenceChanged(const c
   auto blocklist = static_cast<CertBlocklist*>(aClosure);
   MutexAutoLock lock(blocklist->mMutex);
 
   MOZ_LOG(gCertBlockPRLog, LogLevel::Warning,
          ("CertBlocklist::PreferenceChanged %s changed", aPref));
   if (strcmp(aPref, PREF_BACKGROUND_UPDATE_TIMER) == 0) {
     sLastBlocklistUpdate = Preferences::GetUint(PREF_BACKGROUND_UPDATE_TIMER,
                                                 uint32_t(0));
-  } else if (strcmp(aPref, PREF_KINTO_ONECRL_CHECKED) == 0) {
-    sLastKintoUpdate = Preferences::GetUint(PREF_KINTO_ONECRL_CHECKED,
+  } else if (strcmp(aPref, PREF_BLOCKLIST_ONECRL_CHECKED) == 0) {
+    sLastKintoUpdate = Preferences::GetUint(PREF_BLOCKLIST_ONECRL_CHECKED,
                                             uint32_t(0));
   } else if (strcmp(aPref, PREF_MAX_STALENESS_IN_SECONDS) == 0) {
     sMaxStaleness = Preferences::GetUint(PREF_MAX_STALENESS_IN_SECONDS,
                                          uint32_t(0));
   } else if (strcmp(aPref, PREF_ONECRL_VIA_AMO) == 0) {
     sUseAMO = Preferences::GetBool(PREF_ONECRL_VIA_AMO, true);
   }
 }
--- a/security/manager/ssl/tests/unit/test_cert_blocklist.js
+++ b/security/manager/ssl/tests/unit/test_cert_blocklist.js
@@ -42,17 +42,17 @@ stream.init(blockFile,
   FileUtils.PERMS_FILE, 0);
 
 var data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<blocklist xmlns=\"http://www.mozilla.org/2006/addons-blocklist\">\n" +
            "</blocklist>\n";
 stream.write(data, data.length);
 stream.close();
 
-const PREF_KINTO_UPDATE_ENABLED = "services.kinto.update_enabled";
+const PREF_BLOCKLIST_UPDATE_ENABLED = "services.blocklist.update_enabled";
 const PREF_ONECRL_VIA_AMO = "security.onecrl.via.amo";
 
 var revocations = profile.clone();
 revocations.append("revocations.txt");
 if (!revocations.exists()) {
   let existing = do_get_file("test_onecrl/sample_revocations.txt", false);
   existing.copyTo(profile, "revocations.txt");
 }
@@ -220,17 +220,17 @@ function run_test() {
                  " BVio/iQ21GCi2iUven8oJ/gae74=\n" +
                  "MBgxFjAUBgNVBAMMDU90aGVyIHRlc3QgQ0E=\n" +
                  " exJUIJpq50jgqOwQluhVrAzTF74=\n" +
                  "YW5vdGhlciBpbWFnaW5hcnkgaXNzdWVy\n" +
                  " YW5vdGhlciBzZXJpYWwu\n" +
                  " c2VyaWFsMi4=";
 
   // This test assumes OneCRL updates via AMO
-  Services.prefs.setBoolPref(PREF_KINTO_UPDATE_ENABLED, false);
+  Services.prefs.setBoolPref(PREF_BLOCKLIST_UPDATE_ENABLED, false);
   Services.prefs.setBoolPref(PREF_ONECRL_VIA_AMO, true);
 
   add_test(function () {
     // check some existing items in revocations.txt are blocked. Since the
     // CertBlocklistItems don't know about the data they contain, we can use
     // arbitrary data (not necessarily DER) to test if items are revoked or not.
     // This test corresponds to:
     // issuer: c29tZSBpbWFnaW5hcnkgaXNzdWVy
--- a/security/manager/ssl/tests/unit/test_ev_certs.js
+++ b/security/manager/ssl/tests/unit/test_ev_certs.js
@@ -144,17 +144,17 @@ function run_test() {
     check_no_ocsp_requests("no-ocsp-url-cert", SEC_ERROR_POLICY_VALIDATION_FAILED);
   });
 
   // Check OneCRL OCSP request skipping works correctly
   add_test(function () {
     // enable OneCRL OCSP skipping - allow staleness of up to 30 hours
     Services.prefs.setIntPref("security.onecrl.maximum_staleness_in_seconds", 108000);
     // set the blocklist-background-update-timer value to the recent past
-    Services.prefs.setIntPref("services.kinto.onecrl.checked",
+    Services.prefs.setIntPref("services.blocklist.onecrl.checked",
                               Math.floor(Date.now() / 1000) - 1);
     Services.prefs.setIntPref("app.update.lastUpdateTime.blocklist-background-update-timer",
                               Math.floor(Date.now() / 1000) - 1);
     clearOCSPCache();
     // the intermediate should not have an associated OCSP request
     let ocspResponder = start_ocsp_responder(["ev-valid"]);
     check_ee_for_ev("ev-valid", gEVExpected);
     Services.prefs.clearUserPref("security.onecrl.maximum_staleness_in_seconds");
@@ -172,69 +172,69 @@ function run_test() {
     Services.prefs.clearUserPref("security.onecrl.maximum_staleness_in_seconds");
     ocspResponder.stop(run_next_test);
   });
 
   add_test(function () {
     // enable OneCRL OCSP skipping - allow staleness of up to 30 hours
     Services.prefs.setIntPref("security.onecrl.maximum_staleness_in_seconds", 108000);
     // set the blocklist-background-update-timer value to the more distant past
-    Services.prefs.setIntPref("services.kinto.onecrl.checked",
+    Services.prefs.setIntPref("services.blocklist.onecrl.checked",
                               Math.floor(Date.now() / 1000) - 108080);
     Services.prefs.setIntPref("app.update.lastUpdateTime.blocklist-background-update-timer",
                               Math.floor(Date.now() / 1000) - 108080);
     clearOCSPCache();
     let ocspResponder = start_ocsp_responder(
                           gEVExpected ? ["int-ev-valid", "ev-valid"]
                                       : ["ev-valid"]);
     check_ee_for_ev("ev-valid", gEVExpected);
     Services.prefs.clearUserPref("security.onecrl.maximum_staleness_in_seconds");
     ocspResponder.stop(run_next_test);
   });
 
   add_test(function () {
     // test that setting "security.onecrl.via.amo" results in the correct
-    // OCSP behavior when services.kinto.onecrl.checked is in the distant past
+    // OCSP behavior when services.blocklist.onecrl.checked is in the distant past
     // and blacklist-background-update-timer is recent
     Services.prefs.setBoolPref("security.onecrl.via.amo", false);
     // enable OneCRL OCSP skipping - allow staleness of up to 30 hours
     Services.prefs.setIntPref("security.onecrl.maximum_staleness_in_seconds", 108000);
     // set the blocklist-background-update-timer value to the recent past
-    // (services.kinto.onecrl.checked defaults to 0)
+    // (services.blocklist.onecrl.checked defaults to 0)
     Services.prefs.setIntPref("app.update.lastUpdateTime.blocklist-background-update-timer",
                               Math.floor(Date.now() / 1000) - 1);
     clearOCSPCache();
     // the intermediate should have an associated OCSP request
     let ocspResponder = start_ocsp_responder(
                           gEVExpected ? ["int-ev-valid", "ev-valid"]
                                       : ["ev-valid"]);
     check_ee_for_ev("ev-valid", gEVExpected);
     ocspResponder.stop(run_next_test);
   });
 
   add_test(function () {
     // test that setting "security.onecrl.via.amo" results in the correct
-    // OCSP behavior when services.kinto.onecrl.checked is recent
+    // OCSP behavior when services.blocklist.onecrl.checked is recent
     Services.prefs.setBoolPref("security.onecrl.via.amo", false);
 
     // enable OneCRL OCSP skipping - allow staleness of up to 30 hours
     Services.prefs.setIntPref("security.onecrl.maximum_staleness_in_seconds", 108000);
 
-    // now set services.kinto.onecrl.checked to a recent value
-    Services.prefs.setIntPref("services.kinto.onecrl.checked",
+    // now set services.blocklist.onecrl.checked to a recent value
+    Services.prefs.setIntPref("services.blocklist.onecrl.checked",
                               Math.floor(Date.now() / 1000) - 1);
 
     clearOCSPCache();
     // the intermediate should not have an associated OCSP request
     let ocspResponder = start_ocsp_responder(["ev-valid"]);
     check_ee_for_ev("ev-valid", gEVExpected);
     // The tests following this assume no OCSP bypass
     Services.prefs.setIntPref("security.onecrl.maximum_staleness_in_seconds", 0);
     Services.prefs.clearUserPref("security.onecrl.via.amo");
-    Services.prefs.clearUserPref("services.kinto.onecrl.checked");
+    Services.prefs.clearUserPref("services.blocklist.onecrl.checked");
     ocspResponder.stop(run_next_test);
   });
 
   // Test the EV continues to work with flags after successful EV verification
   add_test(function () {
     clearOCSPCache();
     let ocspResponder = start_ocsp_responder(
                           gEVExpected ? ["int-ev-valid", "ev-valid"]
--- a/services/common/blocklist-clients.js
+++ b/services/common/blocklist-clients.js
@@ -15,40 +15,40 @@ this.EXPORTED_SYMBOLS = ["AddonBlocklist
 const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 
 Cu.import("resource://gre/modules/Services.jsm");
 const { Task } = Cu.import("resource://gre/modules/Task.jsm");
 const { OS } = Cu.import("resource://gre/modules/osfile.jsm");
 
 const { loadKinto } = Cu.import("resource://services-common/kinto-offline-client.js");
 
-const PREF_KINTO_BASE                    = "services.kinto.base";
-const PREF_KINTO_BUCKET                  = "services.kinto.bucket";
-const PREF_KINTO_ONECRL_COLLECTION       = "services.kinto.onecrl.collection";
-const PREF_KINTO_ONECRL_CHECKED_SECONDS  = "services.kinto.onecrl.checked";
-const PREF_KINTO_ADDONS_COLLECTION       = "services.kinto.addons.collection";
-const PREF_KINTO_ADDONS_CHECKED_SECONDS  = "services.kinto.addons.checked";
-const PREF_KINTO_PLUGINS_COLLECTION      = "services.kinto.plugins.collection";
-const PREF_KINTO_PLUGINS_CHECKED_SECONDS = "services.kinto.plugins.checked";
-const PREF_KINTO_GFX_COLLECTION          = "services.kinto.gfx.collection";
-const PREF_KINTO_GFX_CHECKED_SECONDS     = "services.kinto.gfx.checked";
+const PREF_SETTINGS_SERVER                   = "services.settings.server";
+const PREF_BLOCKLIST_BUCKET                  = "services.blocklist.bucket";
+const PREF_BLOCKLIST_ONECRL_COLLECTION       = "services.blocklist.onecrl.collection";
+const PREF_BLOCKLIST_ONECRL_CHECKED_SECONDS  = "services.blocklist.onecrl.checked";
+const PREF_BLOCKLIST_ADDONS_COLLECTION       = "services.blocklist.addons.collection";
+const PREF_BLOCKLIST_ADDONS_CHECKED_SECONDS  = "services.blocklist.addons.checked";
+const PREF_BLOCKLIST_PLUGINS_COLLECTION      = "services.blocklist.plugins.collection";
+const PREF_BLOCKLIST_PLUGINS_CHECKED_SECONDS = "services.blocklist.plugins.checked";
+const PREF_BLOCKLIST_GFX_COLLECTION          = "services.blocklist.gfx.collection";
+const PREF_BLOCKLIST_GFX_CHECKED_SECONDS     = "services.blocklist.gfx.checked";
 
 this.FILENAME_ADDONS_JSON  = "blocklist-addons.json";
 this.FILENAME_GFX_JSON     = "blocklist-gfx.json";
 this.FILENAME_PLUGINS_JSON = "blocklist-plugins.json";
 
 
 /**
  * Helper to instantiate a Kinto client based on preferences for remote server
  * URL and bucket name. It uses the `FirefoxAdapter` which relies on SQLite to
  * persist the local DB.
  */
 function kintoClient() {
-  let base = Services.prefs.getCharPref(PREF_KINTO_BASE);
-  let bucket = Services.prefs.getCharPref(PREF_KINTO_BUCKET);
+  let base = Services.prefs.getCharPref(PREF_SETTINGS_SERVER);
+  let bucket = Services.prefs.getCharPref(PREF_BLOCKLIST_BUCKET);
 
   let Kinto = loadKinto();
 
   let FirefoxAdapter = Kinto.adapters.FirefoxAdapter;
 
   let config = {
     remote: base,
     bucket: bucket,
@@ -156,30 +156,30 @@ function* updateJSONBlocklist(filename, 
     Services.cpmm.sendAsyncMessage("Blocklist:reload-from-disk", eventData);
   } catch(e) {
     Cu.reportError(e);
   }
 }
 
 
 this.OneCRLBlocklistClient = new BlocklistClient(
-  Services.prefs.getCharPref(PREF_KINTO_ONECRL_COLLECTION),
-  PREF_KINTO_ONECRL_CHECKED_SECONDS,
+  Services.prefs.getCharPref(PREF_BLOCKLIST_ONECRL_COLLECTION),
+  PREF_BLOCKLIST_ONECRL_CHECKED_SECONDS,
   updateCertBlocklist
 );
 
 this.AddonBlocklistClient = new BlocklistClient(
-  Services.prefs.getCharPref(PREF_KINTO_ADDONS_COLLECTION),
-  PREF_KINTO_ADDONS_CHECKED_SECONDS,
+  Services.prefs.getCharPref(PREF_BLOCKLIST_ADDONS_COLLECTION),
+  PREF_BLOCKLIST_ADDONS_CHECKED_SECONDS,
   updateJSONBlocklist.bind(undefined, FILENAME_ADDONS_JSON)
 );
 
 this.GfxBlocklistClient = new BlocklistClient(
-  Services.prefs.getCharPref(PREF_KINTO_GFX_COLLECTION),
-  PREF_KINTO_GFX_CHECKED_SECONDS,
+  Services.prefs.getCharPref(PREF_BLOCKLIST_GFX_COLLECTION),
+  PREF_BLOCKLIST_GFX_CHECKED_SECONDS,
   updateJSONBlocklist.bind(undefined, FILENAME_GFX_JSON)
 );
 
 this.PluginBlocklistClient = new BlocklistClient(
-  Services.prefs.getCharPref(PREF_KINTO_PLUGINS_COLLECTION),
-  PREF_KINTO_PLUGINS_CHECKED_SECONDS,
+  Services.prefs.getCharPref(PREF_BLOCKLIST_PLUGINS_COLLECTION),
+  PREF_BLOCKLIST_PLUGINS_CHECKED_SECONDS,
   updateJSONBlocklist.bind(undefined, FILENAME_PLUGINS_JSON)
 );
--- a/services/common/blocklist-updater.js
+++ b/services/common/blocklist-updater.js
@@ -1,61 +1,60 @@
 /* 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/. */
 
-this.EXPORTED_SYMBOLS = ["checkVersions", "addTestKintoClient"];
+this.EXPORTED_SYMBOLS = ["checkVersions", "addTestBlocklistClient"];
 
 const { classes: Cc, Constructor: CC, interfaces: Ci, utils: Cu } = Components;
 
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/Task.jsm");
 Cu.importGlobalProperties(['fetch']);
 const BlocklistClients = Cu.import("resource://services-common/blocklist-clients.js", {});
 
-const PREF_KINTO_CHANGES_PATH       = "services.kinto.changes.path";
-const PREF_KINTO_BASE               = "services.kinto.base";
-const PREF_KINTO_BUCKET             = "services.kinto.bucket";
-const PREF_KINTO_LAST_UPDATE        = "services.kinto.last_update_seconds";
-const PREF_KINTO_LAST_ETAG          = "services.kinto.last_etag";
-const PREF_KINTO_CLOCK_SKEW_SECONDS = "services.kinto.clock_skew_seconds";
-const PREF_KINTO_ONECRL_COLLECTION  = "services.kinto.onecrl.collection";
+const PREF_SETTINGS_SERVER              = "services.settings.server";
+const PREF_BLOCKLIST_CHANGES_PATH       = "services.blocklist.changes.path";
+const PREF_BLOCKLIST_BUCKET             = "services.blocklist.bucket";
+const PREF_BLOCKLIST_LAST_UPDATE        = "services.blocklist.last_update_seconds";
+const PREF_BLOCKLIST_LAST_ETAG          = "services.blocklist.last_etag";
+const PREF_BLOCKLIST_CLOCK_SKEW_SECONDS = "services.blocklist.clock_skew_seconds";
 
 
 const gBlocklistClients = {
   [BlocklistClients.OneCRLBlocklistClient.collectionName]: BlocklistClients.OneCRLBlocklistClient,
   [BlocklistClients.AddonBlocklistClient.collectionName]: BlocklistClients.AddonBlocklistClient,
   [BlocklistClients.GfxBlocklistClient.collectionName]: BlocklistClients.GfxBlocklistClient,
   [BlocklistClients.PluginBlocklistClient.collectionName]: BlocklistClients.PluginBlocklistClient
 };
 
 // Add a blocklist client for testing purposes. Do not use for any other purpose
-this.addTestKintoClient = (name, client) => { gBlocklistClients[name] = client; }
+this.addTestBlocklistClient = (name, client) => { gBlocklistClients[name] = client; }
 
 // This is called by the ping mechanism.
 // returns a promise that rejects if something goes wrong
 this.checkVersions = function() {
   return Task.spawn(function* syncClients() {
     // Fetch a versionInfo object that looks like:
     // {"data":[
     //   {
     //     "host":"kinto-ota.dev.mozaws.net",
     //     "last_modified":1450717104423,
     //     "bucket":"blocklists",
     //     "collection":"certificates"
     //    }]}
     // Right now, we only use the collection name and the last modified info
-    let kintoBase = Services.prefs.getCharPref(PREF_KINTO_BASE);
-    let changesEndpoint = kintoBase + Services.prefs.getCharPref(PREF_KINTO_CHANGES_PATH);
-    let blocklistsBucket = Services.prefs.getCharPref(PREF_KINTO_BUCKET);
+    let kintoBase = Services.prefs.getCharPref(PREF_SETTINGS_SERVER);
+    let changesEndpoint = kintoBase + Services.prefs.getCharPref(PREF_BLOCKLIST_CHANGES_PATH);
+    let blocklistsBucket = Services.prefs.getCharPref(PREF_BLOCKLIST_BUCKET);
 
     // Use ETag to obtain a `304 Not modified` when no change occurred.
     const headers = {};
-    if (Services.prefs.prefHasUserValue(PREF_KINTO_LAST_ETAG)) {
-      const lastEtag = Services.prefs.getCharPref(PREF_KINTO_LAST_ETAG);
+    if (Services.prefs.prefHasUserValue(PREF_BLOCKLIST_LAST_ETAG)) {
+      const lastEtag = Services.prefs.getCharPref(PREF_BLOCKLIST_LAST_ETAG);
       if (lastEtag) {
         headers["If-None-Match"] = lastEtag;
       }
     }
 
     let response = yield fetch(changesEndpoint, {headers});
 
     let versionInfo;
@@ -73,18 +72,18 @@ this.checkVersions = function() {
     }
 
     // Record new update time and the difference between local and server time
     let serverTimeMillis = Date.parse(response.headers.get("Date"));
 
     // negative clockDifference means local time is behind server time
     // by the absolute of that value in seconds (positive means it's ahead)
     let clockDifference = Math.floor((Date.now() - serverTimeMillis) / 1000);
-    Services.prefs.setIntPref(PREF_KINTO_CLOCK_SKEW_SECONDS, clockDifference);
-    Services.prefs.setIntPref(PREF_KINTO_LAST_UPDATE, serverTimeMillis / 1000);
+    Services.prefs.setIntPref(PREF_BLOCKLIST_CLOCK_SKEW_SECONDS, clockDifference);
+    Services.prefs.setIntPref(PREF_BLOCKLIST_LAST_UPDATE, serverTimeMillis / 1000);
 
     let firstError;
     for (let collectionInfo of versionInfo.data) {
       // Skip changes that don't concern configured blocklist bucket.
       if (collectionInfo.bucket != blocklistsBucket) {
         continue;
       }
 
@@ -107,12 +106,12 @@ this.checkVersions = function() {
     if (firstError) {
       // cause the promise to reject by throwing the first observed error
       throw firstError;
     }
 
     // Save current Etag for next poll.
     if (response.headers.has("ETag")) {
       const currentEtag = response.headers.get("ETag");
-      Services.prefs.setCharPref(PREF_KINTO_LAST_ETAG, currentEtag);
+      Services.prefs.setCharPref(PREF_BLOCKLIST_LAST_ETAG, currentEtag);
     }
   });
 };
--- a/services/common/tests/unit/test_blocklist_certificates.js
+++ b/services/common/tests/unit/test_blocklist_certificates.js
@@ -35,17 +35,17 @@ function do_get_kinto_collection(collect
 // Some simple tests to demonstrate that the logic inside maybeSync works
 // correctly and that simple kinto operations are working as expected. There
 // are more tests for core Kinto.js (and its storage adapter) in the
 // xpcshell tests under /services/common
 add_task(function* test_something(){
   const configPath = "/v1/";
   const recordsPath = "/v1/buckets/blocklists/collections/certificates/records";
 
-  Services.prefs.setCharPref("services.kinto.base",
+  Services.prefs.setCharPref("services.settings.server",
                              `http://localhost:${server.identity.primaryPort}/v1`);
 
   // register a handler
   function handleResponse (request, response) {
     try {
       const sample = getSampleResponse(request, server.identity.primaryPort);
       if (!sample) {
         do_throw(`unexpected ${request.method} request for ${request.path}?${request.queryString}`);
@@ -88,27 +88,27 @@ add_task(function* test_something(){
   yield collection.db.open();
   list = yield collection.list();
   do_check_eq(list.data.length, 3);
   yield collection.db.close();
 
   // Try to maybeSync with the current lastModified value - no connection
   // should be attempted.
   // Clear the kinto base pref so any connections will cause a test failure
-  Services.prefs.clearUserPref("services.kinto.base");
+  Services.prefs.clearUserPref("services.settings.server");
   yield OneCRLBlocklistClient.maybeSync(4000, Date.now());
 
   // Try again with a lastModified value at some point in the past
   yield OneCRLBlocklistClient.maybeSync(3000, Date.now());
 
   // Check the OneCRL check time pref is modified, even if the collection
   // hasn't changed
-  Services.prefs.setIntPref("services.kinto.onecrl.checked", 0);
+  Services.prefs.setIntPref("services.blocklist.onecrl.checked", 0);
   yield OneCRLBlocklistClient.maybeSync(3000, Date.now());
-  let newValue = Services.prefs.getIntPref("services.kinto.onecrl.checked");
+  let newValue = Services.prefs.getIntPref("services.blocklist.onecrl.checked");
   do_check_neq(newValue, 0);
 });
 
 function run_test() {
   // Set up an HTTP Server
   server = new HttpServer();
   server.start(-1);
 
@@ -136,17 +136,17 @@ function getSampleResponse(req, port) {
     "GET:/v1/?": {
       "sampleHeaders": [
         "Access-Control-Allow-Origin: *",
         "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
         "Content-Type: application/json; charset=UTF-8",
         "Server: waitress"
       ],
       "status": {status: 200, statusText: "OK"},
-      "responseBody": JSON.stringify({"settings":{"cliquet.batch_max_requests":25}, "url":`http://localhost:${port}/v1/`, "documentation":"https://kinto.readthedocs.org/", "version":"1.5.1", "commit":"cbc6f58", "hello":"kinto"})
+      "responseBody": JSON.stringify({"settings":{"batch_max_requests":25}, "url":`http://localhost:${port}/v1/`, "documentation":"https://kinto.readthedocs.org/", "version":"1.5.1", "commit":"cbc6f58", "hello":"kinto"})
     },
     "GET:/v1/buckets/blocklists/collections/certificates/records?_sort=-last_modified": {
       "sampleHeaders": [
         "Access-Control-Allow-Origin: *",
         "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
         "Content-Type: application/json; charset=UTF-8",
         "Server: waitress",
         "Etag: \"3000\""
--- a/services/common/tests/unit/test_blocklist_clients.js
+++ b/services/common/tests/unit/test_blocklist_clients.js
@@ -72,17 +72,17 @@ function* clear_state() {
 
 
 function run_test() {
   // Set up an HTTP Server
   server = new HttpServer();
   server.start(-1);
 
   // Point the blocklist clients to use this local HTTP server.
-  Services.prefs.setCharPref("services.kinto.base",
+  Services.prefs.setCharPref("services.settings.server",
                              `http://localhost:${server.identity.primaryPort}/v1`);
 
   // Setup server fake responses.
   function handleResponse(request, response) {
     try {
       const sample = getSampleResponse(request, server.identity.primaryPort);
       if (!sample) {
         do_throw(`unexpected ${request.method} request for ${request.path}?${request.queryString}`);
@@ -235,17 +235,17 @@ function getSampleResponse(req, port) {
     "GET:/v1/?": {
       "sampleHeaders": [
         "Access-Control-Allow-Origin: *",
         "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
         "Content-Type: application/json; charset=UTF-8",
         "Server: waitress"
       ],
       "status": {status: 200, statusText: "OK"},
-      "responseBody": JSON.stringify({"settings":{"cliquet.batch_max_requests":25}, "url":`http://localhost:${port}/v1/`, "documentation":"https://kinto.readthedocs.org/", "version":"1.5.1", "commit":"cbc6f58", "hello":"kinto"})
+      "responseBody": JSON.stringify({"settings":{"batch_max_requests":25}, "url":`http://localhost:${port}/v1/`, "documentation":"https://kinto.readthedocs.org/", "version":"1.5.1", "commit":"cbc6f58", "hello":"kinto"})
     },
     "GET:/v1/buckets/blocklists/collections/addons/records?_sort=-last_modified": {
       "sampleHeaders": [
         "Access-Control-Allow-Origin: *",
         "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
         "Content-Type: application/json; charset=UTF-8",
         "Server: waitress",
         "Etag: \"3000\""
--- a/services/common/tests/unit/test_blocklist_updater.js
+++ b/services/common/tests/unit/test_blocklist_updater.js
@@ -1,16 +1,16 @@
 Cu.import("resource://testing-common/httpd.js");
 
 var server;
 
-const PREF_KINTO_BASE = "services.kinto.base";
-const PREF_LAST_UPDATE = "services.kinto.last_update_seconds";
-const PREF_LAST_ETAG = "services.kinto.last_etag";
-const PREF_CLOCK_SKEW_SECONDS = "services.kinto.clock_skew_seconds";
+const PREF_SETTINGS_SERVER = "services.settings.server";
+const PREF_LAST_UPDATE = "services.blocklist.last_update_seconds";
+const PREF_LAST_ETAG = "services.blocklist.last_etag";
+const PREF_CLOCK_SKEW_SECONDS = "services.blocklist.clock_skew_seconds";
 
 // Check to ensure maybeSync is called with correct values when a changes
 // document contains information on when a collection was last modified
 add_task(function* test_check_maybeSync(){
   const changesPath = "/v1/buckets/monitor/collections/changes/records";
 
   // register a handler
   function handleResponse (serverTimeMillis, request, response) {
@@ -35,33 +35,33 @@ add_task(function* test_check_maybeSync(
     } catch (e) {
       dump(`${e}\n`);
     }
   }
 
   server.registerPathHandler(changesPath, handleResponse.bind(null, 2000));
 
   // set up prefs so the kinto updater talks to the test server
-  Services.prefs.setCharPref(PREF_KINTO_BASE,
+  Services.prefs.setCharPref(PREF_SETTINGS_SERVER,
     `http://localhost:${server.identity.primaryPort}/v1`);
 
   // set some initial values so we can check these are updated appropriately
   Services.prefs.setIntPref(PREF_LAST_UPDATE, 0);
   Services.prefs.setIntPref(PREF_CLOCK_SKEW_SECONDS, 0);
   Services.prefs.clearUserPref(PREF_LAST_ETAG);
 
 
   let startTime = Date.now();
 
   let updater = Cu.import("resource://services-common/blocklist-updater.js");
 
   let syncPromise = new Promise(function(resolve, reject) {
     // add a test kinto client that will respond to lastModified information
     // for a collection called 'test-collection'
-    updater.addTestKintoClient("test-collection", {
+    updater.addTestBlocklistClient("test-collection", {
       maybeSync(lastModified, serverTime) {
         do_check_eq(lastModified, 1000);
         do_check_eq(serverTime, 2000);
         resolve();
       }
     });
     updater.checkVersions();
   });
@@ -80,17 +80,17 @@ add_task(function* test_check_maybeSync(
               && clockDifference >= Math.floor(startTime / 1000) - 2);
   // Last timestamp was saved. An ETag header value is a quoted string.
   let lastEtag = Services.prefs.getCharPref(PREF_LAST_ETAG);
   do_check_eq(lastEtag, "\"1100\"");
 
   // Simulate a poll with up-to-date collection.
   Services.prefs.setIntPref(PREF_LAST_UPDATE, 0);
   // If server has no change, a 304 is received, maybeSync() is not called.
-  updater.addTestKintoClient("test-collection", {
+  updater.addTestBlocklistClient("test-collection", {
     maybeSync: () => {throw new Error("Should not be called");}
   });
   yield updater.checkVersions();
   // Last update is overwritten
   do_check_eq(Services.prefs.getIntPref(PREF_LAST_UPDATE), 2);
 
 
   // Simulate a server error.
--- a/services/common/tests/unit/test_kinto.js
+++ b/services/common/tests/unit/test_kinto.js
@@ -364,17 +364,17 @@ function getSampleResponse(req, port) {
     "GET:/v1/?": {
       "sampleHeaders": [
         "Access-Control-Allow-Origin: *",
         "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
         "Content-Type: application/json; charset=UTF-8",
         "Server: waitress"
       ],
       "status": {status: 200, statusText: "OK"},
-      "responseBody": JSON.stringify({"settings":{"cliquet.batch_max_requests":25}, "url":`http://localhost:${port}/v1/`, "documentation":"https://kinto.readthedocs.org/", "version":"1.5.1", "commit":"cbc6f58", "hello":"kinto"})
+      "responseBody": JSON.stringify({"settings":{"batch_max_requests":25}, "url":`http://localhost:${port}/v1/`, "documentation":"https://kinto.readthedocs.org/", "version":"1.5.1", "commit":"cbc6f58", "hello":"kinto"})
     },
     "GET:/v1/buckets/default/collections/test_collection/records?_sort=-last_modified": {
       "sampleHeaders": [
         "Access-Control-Allow-Origin: *",
         "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
         "Content-Type: application/json; charset=UTF-8",
         "Server: waitress",
         "Etag: \"1445606341071\""
--- a/testing/profiles/prefs_general.js
+++ b/testing/profiles/prefs_general.js
@@ -104,18 +104,18 @@ user_pref("extensions.update.enabled", f
 // Make sure opening about:addons won't hit the network
 user_pref("extensions.webservice.discoverURL", "http://%(server)s/extensions-dummy/discoveryURL");
 // Make sure AddonRepository won't hit the network
 user_pref("extensions.getAddons.maxResults", 0);
 user_pref("extensions.getAddons.get.url", "http://%(server)s/extensions-dummy/repositoryGetURL");
 user_pref("extensions.getAddons.getWithPerformance.url", "http://%(server)s/extensions-dummy/repositoryGetWithPerformanceURL");
 user_pref("extensions.getAddons.search.browseURL", "http://%(server)s/extensions-dummy/repositoryBrowseURL");
 user_pref("extensions.getAddons.search.url", "http://%(server)s/extensions-dummy/repositorySearchURL");
-// Ensure kinto updates don't hit the network
-user_pref("services.kinto.base", "http://%(server)s/dummy-kinto/v1");
+// Ensure blocklist updates don't hit the network
+user_pref("services.settings.server", "http://%(server)s/dummy-kinto/v1");
 // Make sure that opening the plugins check page won't hit the network
 user_pref("plugins.update.url", "http://%(server)s/plugins-dummy/updateCheckURL");
 // Make sure SNTP requests don't hit the network
 user_pref("network.sntp.pools", "%(server)s");
 // We know the SNTP request will fail, since localhost isn't listening on
 // port 135. The default number of retries (10) is excessive, but retrying
 // at least once will mean that codepath is still tested in automation.
 user_pref("network.sntp.maxRetryCount", 1);
--- a/toolkit/mozapps/extensions/nsBlocklistService.js
+++ b/toolkit/mozapps/extensions/nsBlocklistService.js
@@ -43,17 +43,17 @@ const PREF_BLOCKLIST_URL              = 
 const PREF_BLOCKLIST_ITEM_URL         = "extensions.blocklist.itemURL";
 const PREF_BLOCKLIST_ENABLED          = "extensions.blocklist.enabled";
 const PREF_BLOCKLIST_INTERVAL         = "extensions.blocklist.interval";
 const PREF_BLOCKLIST_LEVEL            = "extensions.blocklist.level";
 const PREF_BLOCKLIST_PINGCOUNTTOTAL   = "extensions.blocklist.pingCountTotal";
 const PREF_BLOCKLIST_PINGCOUNTVERSION = "extensions.blocklist.pingCountVersion";
 const PREF_BLOCKLIST_SUPPRESSUI       = "extensions.blocklist.suppressUI";
 const PREF_ONECRL_VIA_AMO             = "security.onecrl.via.amo";
-const PREF_KINTO_UPDATE_ENABLED       = "services.kinto.update_enabled";
+const PREF_BLOCKLIST_UPDATE_ENABLED   = "services.blocklist.update_enabled";
 const PREF_PLUGINS_NOTIFYUSER         = "plugins.update.notifyUser";
 const PREF_GENERAL_USERAGENT_LOCALE   = "general.useragent.locale";
 const PREF_APP_DISTRIBUTION           = "distribution.id";
 const PREF_APP_DISTRIBUTION_VERSION   = "distribution.version";
 const PREF_EM_LOGGING_ENABLED         = "extensions.logging.enabled";
 const XMLURI_BLOCKLIST                = "http://www.mozilla.org/2006/addons-blocklist";
 const XMLURI_PARSE_ERROR              = "http://www.mozilla.org/newlayout/xml/parsererror.xml"
 const UNKNOWN_XPCOM_ABI               = "unknownABI";
@@ -626,17 +626,17 @@ Blocklist.prototype = {
     request.send(null);
 
     // When the blocklist loads we need to compare it to the current copy so
     // make sure we have loaded it.
     if (!this._isBlocklistLoaded())
       this._loadBlocklist();
 
     // If kinto update is enabled, do the kinto update
-    if (gPref.getBoolPref(PREF_KINTO_UPDATE_ENABLED)) {
+    if (gPref.getBoolPref(PREF_BLOCKLIST_UPDATE_ENABLED)) {
       const updater =
         Components.utils.import("resource://services-common/blocklist-updater.js",
                                 {});
       updater.checkVersions().catch(() => {
         // Before we enable this in release, we want to collect telemetry on
         // failed kinto updates - see bug 1254099
       });
     }
--- a/toolkit/mozapps/extensions/test/xpcshell/head_addons.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/head_addons.js
@@ -1869,18 +1869,17 @@ Services.prefs.setBoolPref("extensions.g
 
 // Disable the compatibility updates window by default
 Services.prefs.setBoolPref("extensions.showMismatchUI", false);
 
 // Point update checks to the local machine for fast failures
 Services.prefs.setCharPref("extensions.update.url", "http://127.0.0.1/updateURL");
 Services.prefs.setCharPref("extensions.update.background.url", "http://127.0.0.1/updateBackgroundURL");
 Services.prefs.setCharPref("extensions.blocklist.url", "http://127.0.0.1/blocklistURL");
-Services.prefs.setCharPref("services.kinto.base",
-                           "http://localhost/dummy-kinto/v1");
+Services.prefs.setCharPref("services.settings.server", "http://localhost/dummy-kinto/v1");
 
 // By default ignore bundled add-ons
 Services.prefs.setBoolPref("extensions.installDistroAddons", false);
 
 // By default use strict compatibility
 Services.prefs.setBoolPref("extensions.strictCompatibility", true);
 
 // By default don't check for hotfixes
--- a/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_regexp.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_regexp.js
@@ -62,17 +62,17 @@ function load_blocklist(aFile, aCallback
 
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + aFile);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   // if we're not using the blocklist.xml for certificate blocklist state,
   // ensure that kinto update is enabled
   if (!Services.prefs.getBoolPref("security.onecrl.via.amo")) {
-    ok(Services.prefs.getBoolPref("services.kinto.update_enabled", false),
+    ok(Services.prefs.getBoolPref("services.blocklist.update_enabled", false),
                                   "Kinto update should be enabled");
   }
   blocklist.notify(null);
 }
 
 
 function end_test() {
   testserver.stop(do_test_finished);