PK

!<[°
Ö44qchrome.manifestPK

!<ôg‚-AA
¤Òbackground.jsPK

!<£ˆ¶__'>en-US/locale/en-US/webcompat.propertiesPK

!<IŠc,xx$¤âexperimentalAPIs/aboutConfigPrefs.jsPK

!<lYi‚--&¤œexperimentalAPIs/aboutConfigPrefs.jsonPK

!<ŽªEÆ!!¤
experimentalAPIs/browserInfo.jsPK

!<Èf¦!¤k%experimentalAPIs/browserInfo.jsonPK

!<ùdù‡‡¤9+experimentalAPIs/l10n.jsPK

!<"²bŒÜ
Ü
¤ö1experimentalAPIs/l10n.jsonPK

!<tuœDD$¤
4experimentalAPIs/pageActionExtras.jsPK

!<Ìü“&¤9experimentalAPIs/pageActionExtras.jsonPK

!<x–0ýËˤæ=experimentalAPIs/tabExtras.jsPK

!<g`¤a¯¯¤ìSexperimentalAPIs/tabExtras.jsonPK

!<®"•ºº¤ØWicons/lightbulb.svgPK

!<¡J­ú
¤ÃZmanifest.jsonPKWPK
!<[°
Ö44chrome.manifestlocale webcompat-reporter en-US en-US/locale/en-US/
PK
!<ôg‚-AA
background.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/. */

"use strict";

/* globals browser */

const Config = {
  newIssueEndpoint: "https://webcompat.com/issues/new",
  newIssueEndpointPref: "newIssueEndpoint",
  screenshotFormat: {
    format: "jpeg",
    quality: 75,
  },
};

browser.pageActionExtras.setLabelForHistogram("webcompat");

browser.pageAction.onClicked.addListener(tab => {
  return getWebCompatInfoForTab(tab).then(
    info => {
      return openWebCompatTab(info);
    },
    err => {
      console.error("WebCompat Reporter: unexpected error", err);
    }
  );
});

browser.aboutConfigPrefs.onEndpointPrefChange.addListener(checkEndpointPref);

checkEndpointPref();

async function checkEndpointPref() {
  const value = await browser.aboutConfigPrefs.getEndpointPref();
  if (value === undefined) {
    browser.aboutConfigPrefs.setEndpointPref(Config.newIssueEndpoint);
  } else {
    Config.newIssueEndpoint = value;
  }
}

function getWebCompatInfoForTab(tab) {
  const {id, url} = tab;
  return Promise.all([
    browser.browserInfo.getBlockList(),
    browser.browserInfo.getBuildID(),
    browser.browserInfo.getGraphicsPrefs(),
    browser.browserInfo.getUpdateChannel(),
    browser.browserInfo.hasTouchScreen(),
    browser.tabExtras.getWebcompatInfo(id),
    browser.tabs.captureTab(id, Config.screenshotFormat).catch(e => {
      console.error("WebCompat Reporter: getting a screenshot failed", e);
      return Promise.resolve(undefined);
    }),
  ]).then(([blockList, buildID, graphicsPrefs, channel, hasTouchScreen,
            frameInfo, screenshot]) => {
    if (channel !== "linux") {
      delete graphicsPrefs["layers.acceleration.force-enabled"];
    }

    const consoleLog = frameInfo.log;
    delete frameInfo.log;

    return Object.assign(frameInfo, {
      tabId: id,
      blockList,
      details: Object.assign(graphicsPrefs, {
        buildID,
        channel,
        consoleLog,
        hasTouchScreen,
        "mixed active content blocked": frameInfo.hasMixedActiveContentBlocked,
        "mixed passive content blocked": frameInfo.hasMixedDisplayContentBlocked,
        "tracking content blocked": frameInfo.hasTrackingContentBlocked ?
                                    `true (${blockList})` : "false",
      }),
      screenshot,
      url,
    });
  });
}

function stripNonASCIIChars(str) {
  // eslint-disable-next-line no-control-regex
  return str.replace(/[^\x00-\x7F]/g, "");
}

browser.l10n.getMessage("wc-reporter.label2").then(
  browser.pageActionExtras.setDefaultTitle, () => {});

browser.l10n.getMessage("wc-reporter.tooltip").then(
  browser.pageActionExtras.setTooltipText, () => {});

async function openWebCompatTab(compatInfo) {
  const url = new URL(Config.newIssueEndpoint);
  const {details} = compatInfo;
  const params = {
    url: `${compatInfo.url}`,
    src: "desktop-reporter",
    details,
    label: [],
  };
  if (details["gfx.webrender.all"] || details["gfx.webrender.enabled"]) {
    params.label.push("type-webrender-enabled");
  }
  if (compatInfo.hasTrackingContentBlocked) {
    params.label.push(`type-tracking-protection-${compatInfo.blockList}`);
  }

  const tab = await browser.tabs.create({url: "about:blank"});
  const json = stripNonASCIIChars(JSON.stringify(params));
  await browser.tabExtras.loadURIWithPostData(tab.id, url.href, json,
                                              "application/json");
  await browser.tabs.executeScript(tab.id, {
    runAt: "document_end",
    code: `(function() {
      async function sendScreenshot(dataURI) {
        const res = await fetch(dataURI);
        const blob = await res.blob();
        postMessage(blob, "${url.origin}");
      }
      sendScreenshot("${compatInfo.screenshot}");
    })()`,
  });
}
PK
!<£ˆ¶__'en-US/locale/en-US/webcompat.properties
wc-reporter.label2=Report Site Issue…
wc-reporter.tooltip=Report a site compatibility issue
PK
!<IŠc,xx$experimentalAPIs/aboutConfigPrefs.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/. */

"use strict";

/* global ExtensionAPI, ExtensionCommon */

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

this.aboutConfigPrefs = class extends ExtensionAPI {
  getAPI(context) {
    const EventManager = ExtensionCommon.EventManager;
    const extensionIDBase = context.extension.id.split("@")[0];
    const endpointPrefName = `extensions.${extensionIDBase}.newIssueEndpoint`;

    return {
      aboutConfigPrefs: {
        onEndpointPrefChange: new EventManager({
          context,
          name: "aboutConfigPrefs.onEndpointPrefChange",
          register: (fire) => {
            const callback = () => {
              fire.async().catch(() => {}); // ignore Message Manager disconnects
            };
            Services.prefs.addObserver(endpointPrefName, callback);
            return () => {
              Services.prefs.removeObserver(endpointPrefName, callback);
            };
          },
        }).api(),
        async getEndpointPref() {
          return Services.prefs.getStringPref(endpointPrefName, undefined);
        },
        async setEndpointPref(value) {
          Services.prefs.setStringPref(endpointPrefName, value);
        },
      },
    };
  }
};
PK
!<lYi‚--&experimentalAPIs/aboutConfigPrefs.json[
  {
    "namespace": "aboutConfigPrefs",
    "description": "experimental API extension to allow access to about:config preferences",
    "events": [
      {
        "name": "onEndpointPrefChange",
        "type": "function",
        "parameters": []
      }
    ],
    "functions": [
      {
        "name": "getEndpointPref",
        "type": "function",
        "description": "Get the endpoint preference's value",
        "parameters": [],
        "async": true
      },
      {
        "name": "setEndpointPref",
        "type": "function",
        "description": "Set the endpoint preference's value",
        "parameters": [
          {
            "name": "value",
            "type": "string",
            "description": "The new value"
          }
        ],
        "async": true
      }
    ]
  }
]
PK
!<ŽªEÆ!!experimentalAPIs/browserInfo.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/. */

"use strict";

/* global ExtensionAPI */

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

this.browserInfo = class extends ExtensionAPI {
  getAPI(context) {
    return {
      browserInfo: {
        async getGraphicsPrefs() {
          const prefs = {};
          for (const [name, dflt] of Object.entries({
            "layers.acceleration.force-enabled": false,
            "gfx.webrender.all": false,
            "gfx.webrender.blob-images": true,
            "gfx.webrender.enabled": false,
            "image.mem.shared": true,
          })) {
            prefs[name] = Services.prefs.getBoolPref(name, dflt);
          }
          return prefs;
        },
        async getAppVersion() {
          return AppConstants.MOZ_APP_VERSION;
        },
        async getBlockList() {
          const trackingTable = Services.prefs.getCharPref("urlclassifier.trackingTable");
          // If content-track-digest256 is in the tracking table,
          // the user has enabled the strict list.
          return trackingTable.includes("content") ? "strict" : "basic";
        },
        async getBuildID() {
          return Services.appinfo.appBuildID;
        },
        async getUpdateChannel() {
          return AppConstants.MOZ_UPDATE_CHANNEL;
        },
        async getPlatform() {
          return AppConstants.platform;
        },
        async hasTouchScreen() {
          const gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
          return gfxInfo.getInfo().ApzTouchInput == 1;
        },
      },
    };
  }
};
PK
!<Èf¦!experimentalAPIs/browserInfo.json[
  {
    "namespace": "browserInfo",
    "description": "experimental API extensions to get browser info not exposed via web APIs",
    "functions": [
      {
        "name": "getAppVersion",
        "type": "function",
        "description": "Gets the app version",
        "parameters": [],
        "async": true
      },
      {
        "name": "getBlockList",
        "type": "function",
        "description": "Gets the current blocklist",
        "parameters": [],
        "async": true
      },
      {
        "name": "getBuildID",
        "type": "function",
        "description": "Gets the build ID",
        "parameters": [],
        "async": true
      },
      {
        "name": "getGraphicsPrefs",
        "type": "function",
        "description": "Gets interesting about:config prefs for graphics",
        "parameters": [],
        "async": true
      },
      {
        "name": "getPlatform",
        "type": "function",
        "description": "Gets the platform",
        "parameters": [],
        "async": true
      },
      {
        "name": "getUpdateChannel",
        "type": "function",
        "description": "Gets the update channel",
        "parameters": [],
        "async": true
      },
      {
        "name": "hasTouchScreen",
        "type": "function",
        "description": "Gets whether a touchscreen is present",
        "parameters": [],
        "async": true
      }
    ]
  }
]
PK
!<ùdù‡‡experimentalAPIs/l10n.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/. */

"use strict";

/* global ExtensionAPI, XPCOMUtils */

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

XPCOMUtils.defineLazyGetter(this, "l10nStrings", function() {
  return Services.strings.createBundle(
    "chrome://webcompat-reporter/locale/webcompat.properties");
});

let l10nManifest;

this.l10n = class extends ExtensionAPI {
  onShutdown(reason) {
    if (l10nManifest) {
      Components.manager.removeBootstrappedManifestLocation(l10nManifest);
    }
  }
  getAPI(context) {
    // Until we move to Fluent (bug 1446164), we're stuck with
    // chrome.manifest for handling localization since its what the
    // build system can handle for localized repacks.
    if (context.extension.rootURI instanceof Ci.nsIJARURI) {
      l10nManifest = context.extension.rootURI.JARFile
                            .QueryInterface(Ci.nsIFileURL).file;
    } else if (context.extension.rootURI instanceof Ci.nsIFileURL) {
      l10nManifest = context.extension.rootURI.file;
    }

    if (l10nManifest) {
      Components.manager.addBootstrappedManifestLocation(l10nManifest);
    } else {
      Cu.reportError("Cannot find webcompat reporter chrome.manifest for registring translated strings");
    }

    return {
      l10n: {
        getMessage(name) {
          try {
            return Promise.resolve(l10nStrings.GetStringFromName(name));
          } catch (e) {
            return Promise.reject(e);
          }
        },
      },
    };
  }
};
PK
!<"²bŒÜ
Ü
experimentalAPIs/l10n.json[
  {
    "namespace": "l10n",
    "description": "A stop-gap L10N API only meant to be used until a Fluent-based API is added in bug 1425104",
    "functions": [
      {
        "name": "getMessage",
        "type": "function",
        "description": "Gets the message with the given name",
        "parameters": [{
          "name": "name",
          "type": "string",
          "description": "The name of the message"
        }],
        "async": true
      }
    ]
  }
]
PK
!<tuœDD$experimentalAPIs/pageActionExtras.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/. */

"use strict";

/* global ExtensionAPI */

this.pageActionExtras = class extends ExtensionAPI {
  getAPI(context) {
    const extension = context.extension;
    const pageActionAPI = extension.apiManager.getAPI("pageAction", extension,
                                                      context.envType);
    const {Management: {global: {windowTracker}}} =
                ChromeUtils.import("resource://gre/modules/Extension.jsm", {});
    return {
      pageActionExtras: {
        async setDefaultTitle(title) {
          pageActionAPI.defaults.title = title;
          // Make sure the new default title is considered right away
          for (const window of windowTracker.browserWindows()) {
            const tab = window.gBrowser.selectedTab;
            if (pageActionAPI.isShown(tab)) {
              pageActionAPI.updateButton(window);
            }
          }
        },
        async setLabelForHistogram(label) {
          pageActionAPI.browserPageAction._labelForHistogram = label;
        },
        async setTooltipText(text) {
          pageActionAPI.browserPageAction.setTooltip(text);
        },
      },
    };
  }
};
PK
!<Ìü“&experimentalAPIs/pageActionExtras.json[
  {
    "namespace": "pageActionExtras",
    "description": "experimental pageAction API extensions",
    "functions": [
      {
        "name": "setDefaultTitle",
        "type": "function",
        "async": true,
        "description": "Set the page action's title for all tabs",
        "parameters": [{
          "name": "title",
          "type": "string",
          "description": "title"
        }]
      },
      {
        "name": "setLabelForHistogram",
        "type": "function",
        "async": true,
        "description": "Set the page action's label for telemetry histograms",
        "parameters": [{
          "name": "label",
          "type": "string",
          "description": "label for the histogram"
        }]
      },
      {
        "name": "setTooltipText",
        "type": "function",
        "async": true,
        "description": "Set the page action's tooltip text",
        "parameters": [{
          "name": "text",
          "type": "string",
          "description": "text"
        }]
      }
    ]
  }
]
PK
!<x–0ýËËexperimentalAPIs/tabExtras.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/. */

"use strict";

/* global ExtensionAPI, XPCOMUtils */

XPCOMUtils.defineLazyGlobalGetters(this, ["URL"]);

function getInfoFrameScript(messageName) {
  /* eslint-env mozilla/frame-script */

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

  function getInnerWindowId(window) {
    return window.windowUtils.currentInnerWindowID;
  }

  function getInnerWindowIDsForAllFrames(window) {
    const innerWindowID = getInnerWindowId(window);
    let ids = [innerWindowID];

    if (window.frames) {
      for (let i = 0; i < window.frames.length; i++) {
        ids = ids.concat(getInnerWindowIDsForAllFrames(window.frames[i]));
      }
    }

    return ids;
  }

  function getLoggedMessages(window, includePrivate = false) {
    const ids = getInnerWindowIDsForAllFrames(window);
    return getConsoleMessages(ids).concat(getScriptErrors(ids, includePrivate))
                                  .sort((a, b) => a.timeStamp - b.timeStamp)
                                  .map(m => m.message);
  }

  function getConsoleMessages(windowIds) {
    const ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"]
                              .getService(Ci.nsIConsoleAPIStorage);
    let messages = [];
    for (const id of windowIds) {
      messages = messages.concat(ConsoleAPIStorage.getEvents(id) || []);
    }
    return messages.map(evt => {
      const {columnNumber, filename, level, lineNumber, timeStamp} = evt;
      const args = evt.arguments.map(arg => {
        return "" + arg;
      }).join(", ");
      const message = `[console.${level}(${args}) ${filename}:${lineNumber}:${columnNumber}]`;
      return {timeStamp, message};
    });
  }

  function getScriptErrors(windowIds, includePrivate = false) {
    const messages = Services.console.getMessageArray() || [];
    return messages.filter(message => {
      if (message instanceof Ci.nsIScriptError) {
        if (!includePrivate && message.isFromPrivateWindow) {
          return false;
        }

        if (windowIds && !windowIds.includes(message.innerWindowID)) {
          return false;
        }

        return true;
      }

      // If this is not an nsIScriptError and we need to do window-based
      // filtering we skip this message.
      return false;
    }).map(error => {
      const {timeStamp, message} = error;
      return {timeStamp, message};
    });
  }

  sendAsyncMessage(messageName, {
    hasMixedActiveContentBlocked: docShell.hasMixedActiveContentBlocked,
    hasMixedDisplayContentBlocked: docShell.hasMixedDisplayContentBlocked,
    hasTrackingContentBlocked: docShell.hasTrackingContentBlocked,
    log: getLoggedMessages(content),
  });
}

this.tabExtras = class extends ExtensionAPI {
  getAPI(context) {
    const {tabManager} = context.extension;
    const {Management: {global: {windowTracker}}} =
                ChromeUtils.import("resource://gre/modules/Extension.jsm", {});
    return {
      tabExtras: {
        async loadURIWithPostData(tabId, url, postData, postDataContentType) {
          const tab = tabManager.get(tabId);
          if (!tab || !tab.browser) {
            return Promise.reject("Invalid tab");
          }

          try {
            new URL(url);
          } catch (_) {
            return Promise.reject("Invalid url");
          }

          if (typeof postData !== "string" && !(postData instanceof String)) {
            return Promise.reject("postData must be a string");
          }

          const stringStream = Cc["@mozilla.org/io/string-input-stream;1"]
                               .createInstance(Ci.nsIStringInputStream);
          stringStream.data = postData;
          const post = Cc["@mozilla.org/network/mime-input-stream;1"]
                       .createInstance(Ci.nsIMIMEInputStream);
          post.addHeader("Content-Type", postDataContentType ||
                                         "application/x-www-form-urlencoded");
          post.setData(stringStream);

          return new Promise(resolve => {
            const listener = {
              onLocationChange(browser, webProgress, request, locationURI, flags) {
                if (webProgress.isTopLevel &&
                    browser === tab.browser &&
                    locationURI.spec === url) {
                  windowTracker.removeListener("progress", listener);
                  resolve();
                }
              },
            };
            windowTracker.addListener("progress", listener);
            let triggeringPrincipal = Services.scriptSecurityManager.createNullPrincipal({});
            tab.browser.webNavigation.loadURIWithOptions(url, null, null, null,
                                                         post, null, null, triggeringPrincipal);
          });
        },
        async getWebcompatInfo(tabId) {
          return new Promise(resolve => {
            const messageName = "WebExtension:GetWebcompatInfo";
            const code = `${getInfoFrameScript.toString()};getInfoFrameScript("${messageName}")`;
            const mm = tabManager.get(tabId).browser.messageManager;
            mm.loadFrameScript(`data:,${encodeURI(code)}`, false);
            mm.addMessageListener(messageName, function receiveFn(message) {
              mm.removeMessageListener(messageName, receiveFn);
              resolve(message.json);
            });
          });
        },
      },
    };
  }
};
PK
!<g`¤a¯¯experimentalAPIs/tabExtras.json[
  {
    "namespace": "tabExtras",
    "description": "experimental tab API extensions",
    "functions": [
      {
        "name": "getWebcompatInfo",
        "type": "function",
        "description": "Gets the content blocking status and script log for a given tab",
        "parameters": [{
          "type": "integer",
          "name": "tabId",
          "minimum": 0
        }],
        "async": true
      },
      {
        "name": "loadURIWithPostData",
        "type": "function",
        "description": "Loads a URI on the given tab using a POST request",
        "parameters": [{
          "type": "integer",
          "name": "tabId",
          "minimum": 0
        }, {
          "type": "string",
          "name": "url"
        }, {
          "type": "string",
          "name": "postData"
        }, {
          "type": "string",
          "name": "postDataContentType"
        }],
        "async": true
      }
    ]
  }
]
PK
!<®"•ººicons/lightbulb.svg<!-- 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/. -->
<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="context-fill" fill-opacity="context-fill-opacity">
  <path d="M8 0C4.3 0 2 2.107 2 5.5c0 2.372 2.065 4.268 3 5V14c0 1.476 1.616 2 3 2s3-.524 3-2v-3.5c.935-.736 3-2.632 3-5C14 2.107 11.7 0 8 0zm1 12H7v-1h2zm-1 2a3.086 3.086 0 0 1-1-.172V13h2v.828A3.047 3.047 0 0 1 8 14zm1.445-4.832A1 1 0 0 0 9 10H7a1 1 0 0 0-.444-.831C5.845 8.691 4 7.1 4 5.5 4 2.607 6.175 2 8 2s4 .607 4 3.5c0 1.6-1.845 3.191-2.555 3.668z"/>
</svg>
PK
!<¡J­ú
manifest.json{
  "manifest_version": 2,
  "name": "WebCompat Reporter",
  "description": "Report site compatibility issues on webcompat.com",
  "author": "Thomas Wisniewski <twisniewski@mozilla.com>",
  "version": "1.1.0",
  "homepage_url": "https://github.com/mozilla/webcompat-reporter",
  "applications": {
    "gecko": {
      "id": "webcompat-reporter@mozilla.org"
    }
  },
  "experiment_apis": {
    "aboutConfigPrefs": {
      "schema": "experimentalAPIs/aboutConfigPrefs.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/aboutConfigPrefs.js",
        "paths": [["aboutConfigPrefs"]]
      }
    },
    "browserInfo": {
      "schema": "experimentalAPIs/browserInfo.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/browserInfo.js",
        "paths": [["browserInfo"]]
      }
    },
    "l10n": {
      "schema": "experimentalAPIs/l10n.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/l10n.js",
        "paths": [["l10n"]]
      }
    },
    "pageActionExtras": {
      "schema": "experimentalAPIs/pageActionExtras.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/pageActionExtras.js",
        "paths": [["pageActionExtras"]]
      }
    },
    "tabExtras": {
      "schema": "experimentalAPIs/tabExtras.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/tabExtras.js",
        "paths": [["tabExtras"]]
      }
    }
  },
  "icons": {
    "16": "icons/lightbulb.svg",
    "32": "icons/lightbulb.svg",
    "48": "icons/lightbulb.svg",
    "96": "icons/lightbulb.svg",
    "128": "icons/lightbulb.svg"
  },
  "permissions": [
    "tabs",
    "<all_urls>"
  ],
  "background": {
    "scripts": [
      "background.js"
    ]
  },
  "page_action": {
    "browser_style": true,
    "default_icon": "icons/lightbulb.svg",
    "default_title": "Report Site Issue…",
    "pinned": false,
    "show_matches": ["http://*/*", "https://*/*"]
  }
}
PKW