PK

!<4¡""Òchrome.manifestPK

!<&¦)ìì¤!bootstrap.jsPK

!<¨+<µµ$¤7chrome/content/data/ua_overrides.jsmPK

!<6[Gjuu#¤.chrome/content/lib/ua_overrider.jsmPK

!<nùšxx¤ä(install.rdfPK

!<ي¢é¤….webextension/background.jsPK

!<{y×ò11>¤Ë4webextension/injections/css/bug0000000-dummy-css-injection.cssPK

!<E+ïƒëë;¤X5webextension/injections/js/bug0000000-dummy-js-injection.jsPK

!<Û.Ž3u
u
¤œ6webextension/manifest.jsonPK		¸PK
!<4¡""chrome.manifestcontent webcompat chrome/content/
PK
!<&¦)ììbootstrap.js/* 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/. */

ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
ChromeUtils.import("resource://gre/modules/Services.jsm");

const PREF_BRANCH = "extensions.webcompat.";
const PREF_DEFAULTS = {
  perform_injections: true,
  perform_ua_overrides: true
};

const INJECTIONS_ENABLE_PREF_NAME = "extensions.webcompat.perform_injections";

const BROWSER_STARTUP_FINISHED_TOPIC = "browser-delayed-startup-finished";

const UA_OVERRIDES_INIT_TOPIC = "useragentoverrides-initialized";
const UA_ENABLE_PREF_NAME = "extensions.webcompat.perform_ua_overrides";

ChromeUtils.defineModuleGetter(this, "UAOverrider", "chrome://webcompat/content/lib/ua_overrider.jsm");
ChromeUtils.defineModuleGetter(this, "UAOverrides", "chrome://webcompat/content/data/ua_overrides.jsm");

let overrider;
let webextensionPort;

function InjectionsEnablePrefObserver() {
  let isEnabled = Services.prefs.getBoolPref(INJECTIONS_ENABLE_PREF_NAME);
  webextensionPort.postMessage({
    type: "injection-pref-changed",
    prefState: isEnabled
  });
}

function UAEnablePrefObserver() {
  let isEnabled = Services.prefs.getBoolPref(UA_ENABLE_PREF_NAME);
  overrider.setShouldOverride(isEnabled);
}

function setDefaultPrefs() {
  const branch = Services.prefs.getDefaultBranch(PREF_BRANCH);
  for (const [key, val] of Object.entries(PREF_DEFAULTS)) {
    // If someone beat us to setting a default, don't overwrite it.
    if (branch.getPrefType(key) !== branch.PREF_INVALID) {
      continue;
    }

    switch (typeof val) {
      case "boolean":
        branch.setBoolPref(key, val);
        break;
      case "number":
        branch.setIntPref(key, val);
        break;
      case "string":
        branch.setCharPref(key, val);
        break;
    }
  }
}

this.install = function() {};
this.uninstall = function() {};

this.startup = function({webExtension}) {
  setDefaultPrefs();

  // Intentionally reset the preference on every browser restart to avoid site
  // breakage by accidentally toggled preferences or by leaving it off after
  // debugging a site.
  Services.prefs.clearUserPref(INJECTIONS_ENABLE_PREF_NAME);
  Services.prefs.addObserver(INJECTIONS_ENABLE_PREF_NAME, InjectionsEnablePrefObserver);

  Services.prefs.clearUserPref(UA_ENABLE_PREF_NAME);
  Services.prefs.addObserver(UA_ENABLE_PREF_NAME, UAEnablePrefObserver);

  // Listen to the useragentoverrides-initialized notification we get and
  // initialize our overrider there. This is done to avoid slowing down the
  // apparent startup process, since we avoid loading anything before the first
  // window is visible to the user. See bug 1371442 for details.
  let uaStartupObserver = {
    observe(aSubject, aTopic, aData) {
      if (aTopic !== UA_OVERRIDES_INIT_TOPIC) {
        return;
      }

      Services.obs.removeObserver(this, UA_OVERRIDES_INIT_TOPIC);
      overrider = new UAOverrider(UAOverrides);
      overrider.init();
    }
  };
  Services.obs.addObserver(uaStartupObserver, UA_OVERRIDES_INIT_TOPIC);

  // Observe browser-delayed-startup-finished and only initialize our embedded
  // WebExtension after that. Otherwise, we'd try to initialize as soon as the
  // browser starts up, which adds a heavy startup penalty.
  let appStartupObserver = {
    observe(aSubject, aTopic, aData) {
      webExtension.startup().then((api) => {
        api.browser.runtime.onConnect.addListener((port) => {
          webextensionPort = port;
        });

        return Promise.resolve();
      }).catch((ex) => {
        console.error(ex);
      });
      Services.obs.removeObserver(this, BROWSER_STARTUP_FINISHED_TOPIC);
    }
  };
  Services.obs.addObserver(appStartupObserver, BROWSER_STARTUP_FINISHED_TOPIC);
};

this.shutdown = function() {
  Services.prefs.removeObserver(INJECTIONS_ENABLE_PREF_NAME, InjectionsEnablePrefObserver);
  Services.prefs.removeObserver(UA_ENABLE_PREF_NAME, UAEnablePrefObserver);
};
PK
!<¨+<µµ$chrome/content/data/ua_overrides.jsm/* 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/. */

/**
 * For detailed information on our policies, and a documention on this format
 * and its possibilites, please check the Mozilla-Wiki at
 *
 * https://wiki.mozilla.org/Compatibility/Go_Faster_Addon/Override_Policies_and_Workflows#User_Agent_overrides
 */
const UAOverrides = [

  /*
   * This is a dummy override that applies a Chrome UA to a dummy site that
   * blocks all browsers but Chrome.
   *
   * This was only put in place to allow QA to test this system addon on an
   * actual site, since we were not able to find a proper override in time.
   */
  {
    baseDomain: "schub.io",
    applications: ["firefox", "fennec"],
    uriMatcher: (uri) => uri.includes("webcompat-addon-testcases.schub.io"),
    uaTransformer: (originalUA) => {
      let prefix = originalUA.substr(0, originalUA.indexOf(")") + 1);
      return `${prefix} AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.98 Safari/537.36`;
    }
  }
];

var EXPORTED_SYMBOLS = ["UAOverrides"]; /* exported UAOverrides */
PK
!<6[Gjuu#chrome/content/lib/ua_overrider.jsm/* 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/. */

ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");

ChromeUtils.defineModuleGetter(this, "Services", "resource://gre/modules/Services.jsm");
ChromeUtils.defineModuleGetter(this, "UserAgentOverrides", "resource://gre/modules/UserAgentOverrides.jsm");
XPCOMUtils.defineLazyServiceGetter(this, "eTLDService", "@mozilla.org/network/effective-tld-service;1", "nsIEffectiveTLDService");

class UAOverrider {
  constructor(overrides) {
    this._overrides = {};
    this._shouldOverride = true;

    this.initOverrides(overrides);
  }

  initOverrides(overrides) {
    // on xpcshell tests, there is no impleentation for nsIXULAppInfo, so this
    // might fail there. To have all of our test cases running at all times,
    // assume they are on Desktop for now.
    let currentApplication = "firefox";
    try {
      currentApplication = Services.appinfo.name.toLowerCase();
    } catch (_) {}

    for (let override of overrides) {
      // Firefox for Desktop is the default application for all overrides.
      if (!override.applications) {
        override.applications = ["firefox"];
      }

      // If the current application is not targeted by the override in question,
      // we can skip adding the override to our checks entirely.
      if (!override.applications.includes(currentApplication)) {
        continue;
      }

      if (!this._overrides[override.baseDomain]) {
        this._overrides[override.baseDomain] = [];
      }

      if (!override.uriMatcher) {
        override.uriMatcher = () => true;
      }

      this._overrides[override.baseDomain].push(override);
    }
  }

  /**
   * Used for disabling overrides when the pref has been flipped to false.
   *
   * Since we no longer use our own event handlers, we check this bool in our
   * override callback and simply return early if we are not supposed to do
   * anything.
   */
  setShouldOverride(newState) {
    this._shouldOverride = newState;
  }

  init() {
    UserAgentOverrides.addComplexOverride(this.overrideCallback.bind(this));
  }

  overrideCallback(channel, defaultUA) {
    if (!this._shouldOverride) {
      return false;
    }

    let uaOverride = this.lookupUAOverride(channel.URI, defaultUA);
    if (uaOverride) {
      console.log("The user agent has been overridden for compatibility reasons.");
      return uaOverride;
    }

    return false;
  }

  /**
   * Try to use the eTLDService to get the base domain (will return example.com
   * for http://foo.bar.example.com/foo/bar).
   *
   * However, the eTLDService is a bit picky and throws whenever we pass a
   * blank host name or an IP into it, see bug 1337785. Since we do not plan on
   * override UAs for such cases, we simply catch everything and return false.
   */
  getBaseDomainFromURI(uri) {
    try {
      return eTLDService.getBaseDomain(uri);
    } catch (_) {
      return false;
    }
  }

  /**
   * This function returns a User Agent based on the URI passed into. All
   * override rules are defined in data/ua_overrides.jsm and the required format
   * is explained there.
   *
   * Since it is expected and designed to have more than one override per base
   * domain, we have to loop over this._overrides[baseDomain], which contains
   * all available overrides.
   *
   * If the uriMatcher function returns true, the uaTransformer function gets
   * called and its result will be used as the Use Agent for the current
   * request.
   *
   * If there are more than one possible overrides, that is if two or more
   * uriMatchers would return true, the first one gets applied.
   */
  lookupUAOverride(uri, defaultUA) {
    let baseDomain = this.getBaseDomainFromURI(uri);
    if (baseDomain && this._overrides[baseDomain]) {
      for (let uaOverride of this._overrides[baseDomain]) {
        if (uaOverride.uriMatcher(uri.specIgnoringRef)) {
          return uaOverride.uaTransformer(defaultUA);
        }
      }
    }

    return false;
  }
}

var EXPORTED_SYMBOLS = ["UAOverrider"]; /* exported UAOverrider */
PK
!<nùšxxinstall.rdf<?xml version="1.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/. -->


<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:em="http://www.mozilla.org/2004/em-rdf#">

  <Description about="urn:mozilla:install-manifest">
    <em:id>webcompat@mozilla.org</em:id>
    <em:version>2.0</em:version>
    <em:type>2</em:type>
    <em:bootstrap>true</em:bootstrap>
    <em:multiprocessCompatible>true</em:multiprocessCompatible>
    <em:hasEmbeddedWebExtension>true</em:hasEmbeddedWebExtension>

    <!-- Firefox Desktop -->
    <em:targetApplication>
      <Description>
        <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
        <em:minVersion>62.0</em:minVersion>
        <em:maxVersion>62.*</em:maxVersion>
      </Description>
    </em:targetApplication>

    <!-- Firefox for Android -->
    <em:targetApplication>
      <Description>
        <em:id>{aa3c5121-dab2-40e2-81ca-7ea25febc110}</em:id>
        <em:minVersion>62.0</em:minVersion>
        <em:maxVersion>62.*</em:maxVersion>
      </Description>
    </em:targetApplication>

    <!-- Front End MetaData -->
    <em:name>Web Compat</em:name>
    <em:description>Urgent post-release fixes for web compatibility.</em:description>
  </Description>
</RDF>
PK
!<ي¢éwebextension/background.js/**
 * For detailed information on our policies, and a documention on this format
 * and its possibilites, please check the Mozilla-Wiki at
 *
 * https://wiki.mozilla.org/Compatibility/Go_Faster_Addon/Override_Policies_and_Workflows#User_Agent_overrides
 */
const contentScripts = [
  {
    matches: ["*://webcompat-addon-testcases.schub.io/*"],
    css: [{file: "injections/css/bug0000000-dummy-css-injection.css"}],
    js: [{file: "injections/js/bug0000000-dummy-js-injection.js"}],
    runAt: "document_start"
  }
];

/* globals browser */

let port = browser.runtime.connect();
let registeredContentScripts = [];

function registerContentScripts() {
  contentScripts.forEach(async (contentScript) => {
    try {
      let handle = await browser.contentScripts.register(contentScript);
      registeredContentScripts.push(handle);
    } catch (ex) {
      console.error("Registering WebCompat GoFaster content scripts failed: ", ex);
    }
  });
}

function unregisterContentScripts() {
  registeredContentScripts.forEach((contentScript) => {
    contentScript.unregister();
  });
}

port.onMessage.addListener((message) => {
  switch (message.type) {
    case "injection-pref-changed":
      if (message.prefState) {
        registerContentScripts();
      } else {
        unregisterContentScripts();
      }
      break;
  }
});

/**
 * Note that we reset all preferences on extension startup, so the injections will
 * never be disabled when this loads up. Because of that, we can simply register
 * right away.
 */
registerContentScripts();
PK
!<{y×ò11>webextension/injections/css/bug0000000-dummy-css-injection.css#css-injection.red {
  background-color: #0f0;
}
PK
!<E+ïƒëë;webextension/injections/js/bug0000000-dummy-js-injection.js"use strict";

/* globals exportFunction */

Object.defineProperty(window.wrappedJSObject, "isTestFeatureSupported", {
  get: exportFunction(function() {
    return true;
  }, window),

  set: exportFunction(function() {}, window)
});
PK
!<Û.Ž3u
u
webextension/manifest.json{
  "manifest_version": 2,
  "name": "Web Compat",
  "description": "Urgent post-release fixes for web compatibility.",
  "version": "2.0",

  "applications": {
    "gecko": {
      "id": "webcompat@mozilla.org",
      "strict_min_version": "59.0b5"
    }
  },

  "permissions": [
    "<all_urls>"
  ],

  "background": {
    "scripts": [
      "background.js"
    ]
  }
}
PK		¸