The Tor Browser: comparison netwerk/protocol/http/UserAgentOverrides.jsm

--1:000000000000
+:84af3a1c59fe
+/* 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";
+this.EXPORTED_SYMBOLS = [ "UserAgentOverrides" ];
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/UserAgentUpdates.jsm");
+const OVERRIDE_MESSAGE = "Useragent:GetOverride";
+const PREF_OVERRIDES_ENABLED = "general.useragent.site_specific_overrides";
+const DEFAULT_UA = Cc["@mozilla.org/network/protocol;1?name=http"]
+.getService(Ci.nsIHttpProtocolHandler)
+.userAgent;
+const MAX_OVERRIDE_FOR_HOST_CACHE_SIZE = 250;
+XPCOMUtils.defineLazyServiceGetter(this, "ppmm",
+"@mozilla.org/parentprocessmessagemanager;1",
+"nsIMessageListenerManager");  // Might have to make this broadcast?
+var gPrefBranch;
+var gOverrides = new Map;
+var gUpdatedOverrides;
+var gOverrideForHostCache = new Map;
+var gInitialized = false;
+var gOverrideFunctions = [
+function (aHttpChannel) UserAgentOverrides.getOverrideForURI(aHttpChannel.URI)
+];
+var gBuiltUAs = new Map;
+this.UserAgentOverrides = {
+init: function uao_init() {
+if (gInitialized)
+return;
+gPrefBranch = Services.prefs.getBranch("general.useragent.override.");
+gPrefBranch.addObserver("", buildOverrides, false);
+ppmm.addMessageListener(OVERRIDE_MESSAGE, this);
+Services.prefs.addObserver(PREF_OVERRIDES_ENABLED, buildOverrides, false);
+try {
+Services.obs.addObserver(HTTP_on_modify_request, "http-on-modify-request", false);
+} catch (x) {
+// The http-on-modify-request notification is disallowed in content processes.
+}
+UserAgentUpdates.init(function(overrides) {
+gOverrideForHostCache.clear();
+if (overrides) {
+for (let domain in overrides) {
+overrides[domain] = getUserAgentFromOverride(overrides[domain]);
+}
+overrides.get = function(key) this[key];
+}
+gUpdatedOverrides = overrides;
+});
+buildOverrides();
+gInitialized = true;
+},
+addComplexOverride: function uao_addComplexOverride(callback) {
+// Add to front of array so complex overrides have precedence
+gOverrideFunctions.unshift(callback);
+},
+getOverrideForURI: function uao_getOverrideForURI(aURI) {
+let host = aURI.asciiHost;
+if (!gInitialized ||
+(!gOverrides.size && !gUpdatedOverrides) ||
+!(host)) {
+return null;
+}
+let override = gOverrideForHostCache.get(host);
+if (override !== undefined)
+return override;
+function findOverride(overrides) {
+let searchHost = host;
+let userAgent = overrides.get(searchHost);
+while (!userAgent) {
+let dot = searchHost.indexOf('.');
+if (dot === -1) {
+return null;
+}
+searchHost = searchHost.slice(dot + 1);
+userAgent = overrides.get(searchHost);
+}
+return userAgent;
+}
+override = (gOverrides.size && findOverride(gOverrides))
+|| (gUpdatedOverrides && findOverride(gUpdatedOverrides));
+if (gOverrideForHostCache.size >= MAX_OVERRIDE_FOR_HOST_CACHE_SIZE) {
+gOverrideForHostCache.clear();
+}
+gOverrideForHostCache.set(host, override);
+return override;
+},
+uninit: function uao_uninit() {
+if (!gInitialized)
+return;
+gInitialized = false;
+gPrefBranch.removeObserver("", buildOverrides);
+Services.prefs.removeObserver(PREF_OVERRIDES_ENABLED, buildOverrides);
+Services.obs.removeObserver(HTTP_on_modify_request, "http-on-modify-request");
+},
+receiveMessage: function(aMessage) {
+let name = aMessage.name;
+switch (name) {
+case OVERRIDE_MESSAGE:
+let uri = aMessage.data.uri;
+return this.getOverrideForURI(uri);
+default:
+throw("Wrong Message in UserAgentOverride: " + name);
+}
+}
+};
+function getUserAgentFromOverride(override)
+{
+let userAgent = gBuiltUAs.get(override);
+if (userAgent !== undefined) {
+return userAgent;
+}
+let [search, replace] = override.split("#", 2);
+if (search && replace) {
+userAgent = DEFAULT_UA.replace(new RegExp(search, "g"), replace);
+} else {
+userAgent = override;
+}
+gBuiltUAs.set(override, userAgent);
+return userAgent;
+}
+function buildOverrides() {
+gOverrides.clear();
+gOverrideForHostCache.clear();
+if (!Services.prefs.getBoolPref(PREF_OVERRIDES_ENABLED))
+return;
+let builtUAs = new Map;
+let domains = gPrefBranch.getChildList("");
+for (let domain of domains) {
+let override = gPrefBranch.getCharPref(domain);
+let userAgent = getUserAgentFromOverride(override);
+if (userAgent != DEFAULT_UA) {
+gOverrides.set(domain, userAgent);
+}
+}
+}
+function HTTP_on_modify_request(aSubject, aTopic, aData) {
+let channel = aSubject.QueryInterface(Ci.nsIHttpChannel);
+for (let callback of gOverrideFunctions) {
+let modifiedUA = callback(channel, DEFAULT_UA);
+if (modifiedUA) {
+channel.setRequestHeader("User-Agent", modifiedUA, false);
+return;
+}
+}
+}

The Tor Browser / file comparison

comparison: netwerk/protocol/http/UserAgentOverrides.jsm

netwerk/protocol/http/UserAgentOverrides.jsm