bump version to 4.0.3

Clean up disabled Private Mode notice. Fixes #878

.eslintignore

@@ -1 +1 @@
-testpilot-metrics.js
+lib/testpilot/*.js

.eslintrc.js

@@ -1,22 +1,31 @@
 module.exports = {
+  "parserOptions": {
+    "ecmaVersion": 8
+  },
   "env": {
     "browser": true,
     "es6": true,
     "node": true,
     "webextensions": true
   },
-  "extends": [
-    "eslint:recommended"
-  ],
   "globals": {
+    "Utils": true,
     "CustomizableUI": true,
     "CustomizableWidgets": true,
     "SessionStore": true,
-    "Services": true
+    "Services": true,
+    "Components": true,
+    "XPCOMUtils": true,
+    "OS": true,
+    "ADDON_UNINSTALL": true,
+    "ADDON_DISABLE": true
   },
   "plugins": [
     "promise",
-    "no-unescaped"
+    "no-unsanitized"
+  ],
+  "extends": [
+    "eslint:recommended"
   ],
   "root": true,
   "rules": {
@@ -29,8 +38,18 @@ module.exports = {
     "promise/no-promise-in-callback": "warn",
     "promise/no-return-wrap": "error",
     "promise/param-names": "error",
-    "no-unescaped/no-key-assignment": "error",
-    "no-unescaped/enforce": "error",
+
+    "no-unsanitized/method": [
+      "error"
+    ],
+    "no-unsanitized/property": [
+      "error",
+      {
+        "escape": {
+          "taggedTemplates": ["escaped"]
+        }
+      }
+    ],
 
     "eqeqeq": "error",
     "indent": ["error", 2],

.gitignore

@@ -1,8 +1,10 @@
 .DS_Store
+package-lock.json
 node_modules
 README.html
 *.xpi
 *.swp
+*.swo
 .vimrc
 .env
 addon.env

.jpmignore

@@ -3,6 +3,7 @@ docs/
 test/
 .npm/
 node_modules/
+bin/
 
 .env
 .eslintrc.js
@@ -14,6 +15,7 @@ node_modules/
 .stylelintrc
 .travis.yml
 *.xpi
+*.md
 .vimrc
 .DS_Store
 .gdb_history

.stylelintrc

@@ -11,7 +11,7 @@
     "declaration-block-no-duplicate-properties": true,
     "order/declaration-block-properties-alphabetical-order": true,
     "property-blacklist": [
-      "/height/",
+      "/(min[-]|max[-])height/",
       "/width/",
       "/top/",
       "/bottom/",

CODE_OF_CONDUCT.md

@@ -0,0 +1,3 @@
+# Code Of Conduct
+
+This add-on follows the [Mozilla Community Participation Guidelines](https://www.mozilla.org/en-US/about/governance/policies/participation/) for our code of conduct.

CONTRIBUTING.md

@@ -0,0 +1,35 @@
+# Contributing
+
+Everyone is welcome to contribute to containers. Reach out to team members if you have questions:
+
+- IRC: #containers on irc.mozilla.org
+- Email: containers@mozilla.com
+
+## Filing bugs
+
+If you find a bug with containers, please file a issue.
+
+Check first if the bug might already exist: https://github.com/mozilla/testpilot-containers/issues
+
+[Open an issue](https://github.com/mozilla/testpilot-containers/issues/new)
+
+1. Visit about:support
+2. Click "Copy raw data to clipboard" and paste into the bug. Alternatively copy the following sections into the issue:
+  - Application Basics
+  - Nightly Features (if you are in nightly)
+  - Extensions
+  - Experimental Features
+3. Include clear steps to reproduce the issue you have experienced.
+4. Include screenshots if possible.
+
+## Sending Pull Requests
+
+Patches should be submitted as pull requests. When submitting patches as PRs:
+
+- You agree to license your code under the project's open source license (MPL 2.0).
+- Base your branch off the current master (see below for an example workflow).
+- Add both your code and new tests if relevant.
+- Run npm test to make sure all tests still pass.
+- Please do not include merge commits in pull requests; include only commits with the new relevant code.
+
+See the main [README](./README.md) for information on prerequisites, installing, running and testing.

README.md

@@ -1,54 +1,69 @@
-# Containers: Test Pilot Experiment
+# Multi-Account Containers
 
-[![Available on Test Pilot](https://img.shields.io/badge/available_on-Test_Pilot-0996F8.svg)](https://testpilot.firefox.com/experiments/containers)
 
-[Embedded Web Extension](https://developer.mozilla.org/en-US/Add-ons/WebExtensions/Embedded_WebExtensions) to experiment with [Containers](https://blog.mozilla.org/tanvi/2016/06/16/contextual-identities-on-the-web/) in [Firefox Test Pilot](https://testpilot.firefox.com/) to learn:
+The Firefox Multi-Account Containers extension lets you carve out a separate box for each of your online lives – no more opening a different browser just to check your work email! [Learn More Here](https://blog.mozilla.org/firefox/introducing-firefox-multi-account-containers/)
 
-* Will a general Firefox audience understand the Containers feature?
-* Is the UI as currently implemented in Nightly clear or discoverable?
+[Available on addons.mozilla.org](https://addons.mozilla.org/en-GB/firefox/addon/multi-account-containers/)
 
-See [the Product Hypothesis Document for more
-details](https://docs.google.com/document/d/1WQdHTVXROk7dYkSFluc6_hS44tqZjIrG9I-uPyzevE8/edit?ts=5824ba12#).
+**Note:** Firefox 57 + 58 users should Install from our [latest GitHub Release](https://github.com/mozilla/testpilot-containers/releases/latest)
+
+For more info, see: 
+
+* [Test Pilot Product Hypothesis Document](https://docs.google.com/document/d/1WQdHTVXROk7dYkSFluc6_hS44tqZjIrG9I-uPyzevE8/edit#)
+* [Shield Product Hypothesis Document](https://docs.google.com/document/d/1vMD-fH_5hGDDqNvpRZk12_RhCN2WAe4_yaBamaNdtik/edit#)
 
 
 ## Requirements
 
 * node 7+ (for jpm)
-* Firefox 51+
-
-
-## Run it
-
-See Development
+* Firefox 53+
 
 
 ## Development
+
+### Web Extension Development
+
+Since Firefox 57, this extension can now be run without any of the legacy components that were previously needed.
+
+1. Install web-ext with npm
+2. cd webextension; web-ext run -f Nightly
+
+This will work in other builds of Firefox however certain features won't work and you will need to manually flip preferences to enable containers. All other sections of this guide talk about using the legacy setup with jpm.
+
+
+## Legacy Development
+
 ### Development Environment
 
 Add-on development is better with [a particular  environment](https://developer.mozilla.org/en-US/Add-ons/Setting_up_extension_development_environment). One simple way to get that environment set up is to install the [DevPrefs add-on](https://addons.mozilla.org/en-US/firefox/addon/devprefs/). You can make a custom Firefox profile that includes the DevPrefs add-on, and use that profile when you run the code in this repository. 
 
-
 1. Make a new profile by running `/path/to/firefox -P`, which launches the profile editor. "Create Profile" -- name it whatever you wish (e.g. 'addon_dev') and store it in the default location. It's probably best to deselect the option to "Use without asking," since you probably don't want to use this as your default profile.
 
 2. Once you've created your profile, click "Start Firefox". A new instance of Firefox should launch. Go to Tools->Add-ons and search for "DevPrefs". Install it. Quit Firefox.
 
 3. Now you have a new, vanilla Firefox profile with the DevPrefs add-on installed. You can use your new profile with the code in _this_ repository like so:
 
-**Beta building**
+#### Run the `.xpi` file in an unbranded build
+Release & Beta channels do not allow un-signed add-ons, even with the DevPrefs. So, you must run the add-on in an [unbranded build](https://wiki.mozilla.org/Add-ons/Extension_Signing#Unbranded_Builds):
 
-To build this for 51 beta just using the downloaded version of beta will not work as XPI signature checking is disabled fully.
+1. Download and install an un-branded build of Firefox
+2. Download the latest `.xpi` from this repository's releases
+3. Run the un-branded build of Firefox with your DevPrefs profile
+4. Go to `about:addons`
+5. Click the gear, and select "Install Add-on From File..."
+6. Select the `.xpi` file
 
-The only way to run the experiment is using an [unbranded version build](https://wiki.mozilla.org/Add-ons/Extension_Signing#Unbranded_Builds) or to build beta yourself:
+#### Correct prefs
 
-1. [Download the mozilla-beta repo](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Source_Code/Mercurial#mozilla-beta_(prerelease_development_tree))
-2. [Create a mozconfig file](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Build_Instructions/Configuring_Build_Options) - probably optional
-3. `cd <reponame>`
-3. `./mach bootstrap`
-4. `./mach build`
-5. Follow the above instructions by creating the new profile via: `~/<reponame>/obj-x86_64-pc-linux-gnu/dist/bin/firefox -P` (Where "obj-x86_64-pc-linux-gnu" may be different depending on platform obj-...)
+Whilst this is still using legacy code to test you will need the following in your profile:
+
+Change the following prefs in about:config:
+
+- extensions.legacy.enabled = true
+- xpinstall.signatures.required = false
 
 
-### Run with jpm
+#### Run the TxP experiment with `jpm`
 
 1. `git clone git@github.com:mozilla/testpilot-containers.git`
 2. `cd testpilot-containers`
@@ -57,11 +72,11 @@ The only way to run the experiment is using an [unbranded version build](https:/
 
 Check out the [Browser Toolbox](https://developer.mozilla.org/en-US/docs/Tools/Browser_Toolbox) for more information about debugging add-on code.
 
-
 ### Building .xpi
 
-To build a local .xpi, use the plain [`jpm
-xpi`](https://developer.mozilla.org/en-US/Add-ons/SDK/Tools/jpm#jpm_xpi) command.
+To build a local testpilot-containers.xpi, use the plain [`jpm
+xpi`](https://developer.mozilla.org/en-US/Add-ons/SDK/Tools/jpm#jpm_xpi) command,
+or run `npm run build`.
 
 ### Signing an .xpi
 
@@ -75,6 +90,11 @@ add-on](https://addons.mozilla.org/en-US/developers/addon/containers-experiment/
 ### Testing
 TBD
 
-
 ### Distributing
 TBD
+
+### Links
+
+- [Licence](./LICENSE.txt)
+- [Contributing](./CONTRIBUTING.md)
+- [Code Of Conduct](./CODE_OF_CONDUCT.md)

bootstrap.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const PREFS = [
+  {
+    name: "privacy.userContext.enabled",
+    value: true,
+    type: "bool",
+    default: false
+  },
+  {
+    name: "privacy.userContext.longPressBehavior",
+    value: 2,
+    type: "int",
+    default: 0
+  },
+  {
+    name: "privacy.userContext.ui.enabled",
+    value: true, // Post web ext we will be setting this true
+    type: "bool",
+    default: true
+  },
+  {
+    name: "privacy.usercontext.about_newtab_segregation.enabled",
+    value: true,
+    type: "bool",
+    default: false
+  },
+];
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const Cc = Components.classes;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+const { TextDecoder, TextEncoder } = Cu.import("resource://gre/modules/commonjs/toolkit/loader.js", {});
+
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+                                  "resource://gre/modules/osfile.jsm");
+
+const JETPACK_DIR_BASENAME = "jetpack";
+const EXTENSION_ID = "@testpilot-containers";
+
+function loadStyles(resourceURI) {
+  const styleSheetService = Cc["@mozilla.org/content/style-sheet-service;1"]
+                            .getService(Ci.nsIStyleSheetService);
+  const styleURI = styleSheet(resourceURI);
+  const sheetType = styleSheetService.AGENT_SHEET;
+  styleSheetService.loadAndRegisterSheet(styleURI, sheetType);
+}
+
+function styleSheet(resourceURI) {
+  return Services.io.newURI("data/usercontext.css", null, resourceURI);
+}
+
+function unloadStyles(resourceURI) {
+  const styleURI = styleSheet(resourceURI);
+  const styleSheetService = Cc["@mozilla.org/content/style-sheet-service;1"]
+                  .getService(Ci.nsIStyleSheetService);
+  const sheetType = styleSheetService.AGENT_SHEET;
+  if (styleSheetService.sheetRegistered(styleURI, sheetType)) {
+    styleSheetService.unregisterSheet(styleURI, sheetType);
+  }
+}
+
+function filename() {
+  const storeFile = Services.dirsvc.get("ProfD", Ci.nsIFile);
+  storeFile.append(JETPACK_DIR_BASENAME);
+  storeFile.append(EXTENSION_ID);
+  storeFile.append("simple-storage");
+  storeFile.append("store.json");
+  return storeFile.path;
+}
+
+async function makeFilepath() {
+  const storeFile = Services.dirsvc.get("ProfD", Ci.nsIFile);
+  storeFile.append(JETPACK_DIR_BASENAME);
+  await OS.File.makeDir(storeFile.path, { ignoreExisting: true });
+  storeFile.append(EXTENSION_ID);
+  await OS.File.makeDir(storeFile.path, { ignoreExisting: true });
+  storeFile.append("simple-storage");
+  await OS.File.makeDir(storeFile.path, { ignoreExisting: true });
+}
+
+async function getConfig() {
+  let savedConfig = {savedConfiguration: {}};
+  try {
+    const bytes = await OS.File.read(filename());
+    const raw = new TextDecoder().decode(bytes) || "";
+    if (raw) {
+      savedConfig = JSON.parse(raw);
+    }
+  } catch (e) {
+    // ignore file read errors, sometimes they happen and I'm not sure if we can fix
+  }
+  return savedConfig;
+}
+
+async function initConfig() {
+  const savedConfig = await getConfig();
+  savedConfig.savedConfiguration.version = 2;
+  if (!("prefs" in savedConfig.savedConfiguration)) {
+    savedConfig.savedConfiguration.prefs = {};
+    PREFS.forEach((pref) => {
+      if ("int" === pref.type) {
+        savedConfig.savedConfiguration.prefs[pref.name] = Services.prefs.getIntPref(pref.name);
+      } else {
+        savedConfig.savedConfiguration.prefs[pref.name] = Services.prefs.getBoolPref(pref.name);
+      }
+    });
+  }
+  const serialized = JSON.stringify(savedConfig);
+  const bytes = new TextEncoder().encode(serialized) || "";
+  await makeFilepath();
+  await OS.File.writeAtomic(filename(), bytes, { });
+}
+
+function setPrefs() {
+  PREFS.forEach((pref) => {
+    if ("int" === pref.type) {
+      Services.prefs.setIntPref(pref.name, pref.value);
+    } else {
+      Services.prefs.setBoolPref(pref.name, pref.value);
+    }
+  });
+}
+
+// eslint-disable-next-line no-unused-vars
+async function install() {
+  await initConfig();
+  setPrefs();
+}
+
+// eslint-disable-next-line no-unused-vars
+async function uninstall(aData, aReason) {
+  if (aReason === ADDON_UNINSTALL
+      || aReason === ADDON_DISABLE) {
+    const config = await getConfig();
+    const storedPrefs = config.savedConfiguration.prefs || {};
+    PREFS.forEach((pref) => {
+      let value = pref.default;
+      if (pref.name in storedPrefs) {
+        value = storedPrefs[pref.name];
+      }
+      if ("int" === pref.type) {
+        Services.prefs.setIntPref(pref.name, value);
+      } else {
+        Services.prefs.setBoolPref(pref.name, value);
+      }
+    });
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+function startup({webExtension, resourceURI}) {
+  const version = Services.appinfo.version;
+  const versionMatch = version.match(/^([0-9]+)\./)[1];
+  if (versionMatch === "55"
+      || versionMatch === "56") {
+    loadStyles(resourceURI);
+  }
+  // Reset prefs that may have changed, or are legacy
+  install();
+  // Start the embedded webextension.
+  webExtension.startup();
+}
+
+// eslint-disable-next-line no-unused-vars
+function shutdown({resourceURI}) {
+  unloadStyles(resourceURI);
+}
+

data/usercontext.css

@@ -1,108 +1,3 @@
-/* HACK: Custom Container vars do not propigate correctly
-until the container tab is blurred and refocused,
-adding the data-identity-color with the default hex
-value, or chrome url path as an alternate selector mitiages this bug.*/
-[data-identity-color="blue"],
-[data-identity-color="#00a7e0"] {
-  --identity-tab-color: #37adff;
-  --identity-icon-color: #37adff;
-}
-
-[data-identity-color="turquoise"],
-[data-identity-color="#01bdad"] {
-  --identity-tab-color: #00c79a;
-  --identity-icon-color: #00c79a;
-}
-
-[data-identity-color="green"],
-[data-identity-color="#7dc14c"] {
-  --identity-tab-color: #51cd00;
-  --identity-icon-color:  #51cd00;
-}
-
-[data-identity-color="yellow"],
-[data-identity-color="#ffcb00"] {
-  --identity-tab-color: #ffcb00;
-  --identity-icon-color: #ffcb00;
-}
-
-[data-identity-color="orange"],
-[data-identity-color="#f89c24"] {
-  --identity-tab-color: #ff9f00;
-  --identity-icon-color: #ff9f00;
-}
-
-[data-identity-color="red"],
-[data-identity-color="#d92215"] {
-  --identity-tab-color: #ff613d;
-  --identity-icon-color: #ff613d;
-}
-
-[data-identity-color="pink"],
-[data-identity-color="#ee5195"] {
-  --identity-tab-color: #ff4bda;
-  --identity-icon-color: #ff4bda;
-}
-
-[data-identity-color="purple"],
-[data-identity-color="#7a2f7a"] {
-  --identity-tab-color: #af51f5;
-  --identity-icon-color: #af51f5;
-}
-
-[data-identity-icon="fingerprint"],
-[data-identity-icon="chrome://browser/skin/usercontext/personal.svg"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#fingerprint");
-}
-
-[data-identity-icon="briefcase"],
-[data-identity-icon="chrome://browser/skin/usercontext/work.svg"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#briefcase");
-}
-
-[data-identity-icon="dollar"],
-[data-identity-icon="chrome://browser/skin/usercontext/banking.svg"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#dollar");
-}
-
-[data-identity-icon="cart"],
-[data-identity-icon="chrome://browser/skin/usercontext/cart.svg"],
-[data-identity-icon="chrome://browser/skin/usercontext/shopping.svg"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#cart");
-}
-
-[data-identity-icon="circle"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#circle");
-}
-
-[data-identity-icon="gift"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#gift");
-}
-
-[data-identity-icon="vacation"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#vacation");
-}
-
-[data-identity-icon="food"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#food");
-}
-
-[data-identity-icon="fruit"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#fruit");
-}
-
-[data-identity-icon="pet"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#pet");
-}
-
-[data-identity-icon="tree"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#tree");
-}
-
-[data-identity-icon="chill"] {
-  --identity-icon: url("resource://testpilot-containers/data/usercontext.svg#chill");
-}
-
 #userContext-indicator {
   height: 16px;
   list-style-image: none !important;
@@ -129,19 +24,6 @@ value, or chrome url path as an alternate selector mitiages this bug.*/
   display: none;
 }
 
-.userContext-icon,
-.menuitem-iconic[data-usercontextid] > .menu-iconic-left > .menu-iconic-icon,
-.subviewbutton[usercontextid] > .toolbarbutton-icon,
-#userContext-indicator {
-  background-image: var(--identity-icon) !important;
-  background-position: center center;
-  background-repeat: no-repeat;
-  background-size: contain;
-  fill: var(--identity-icon-color) !important;
-  filter: url(/img/filters.svg#fill);
-  filter: url(resource://testpilot-containers/data/filters.svg#fill);
-}
-
 /* containers experiment */
 
 /* reset nightly containers */
@@ -200,7 +82,7 @@ special cases are addressed below */
 }
 
 #new-tab-overlay {
-  --icon-size: 26px;
+  --icon-size: 16px;
   -moz-appearance: none;
   background: transparent;
   font-style: -moz-use-system-font;
@@ -252,8 +134,8 @@ special cases are addressed below */
 }
 
 #new-tab-overlay .menuitem-iconic[data-usercontextid] > .menu-iconic-left > .menu-iconic-icon {
-  block-height: var(--icon-size);
-  block-width: var(--icon-size);
+  block-size: var(--icon-size);
+  inline-size: var(--icon-size);
 }
 
 .menuitem-iconic[data-usercontextid] > .menu-iconic-left {

docs/metrics.md

@@ -1,266 +0,0 @@
-# METRICS
-
-## Data Analysis
-The collected data will primarily be used to answer the following questions.
-Images are used for visualization and are not composed of actual data.
-
-### Do users install and run this?
-
-What is the overall engagement of the Containers experiment?
-**This is the standard Daily Active User (DAU) and Monthly Active User (MAU) analysis.**
-
-This captures data from the users who have the add-on installed, regardless of
-whether they are actively interacting with it.
-
-![](kpi-1.png)
-
-### Immediate Questions
-
-* Do people use the containers feature & how do people create new container tabs?
-  * Click to create new container tab
-    * \+ `entry-point` value: "tab-bar" or "pop-up"
-* Do people who use the containers feature continue to use it?
-  * Retention: opening a second container tab (second tab in the same container, or a tab in a second container?)
-* What containers do people use?
-  * userContextId
-    * \+ Number of tabs in the container (when should we measure this? on every tab open?)
-* Do people edit their containers?
-  * Click on "Edit Containers"
-  * Click to edit a single container
-    * Click "OK"
-  * Click to delete a single container
-    * Click "OK"
-  * Click to add a container
-    * Click "OK"
-* Do people sort the tabs?
-  * Click sort
-    * \+ Number of tabs when clicked
-  * Average number of container tabs when sort was clicked
-* Do users show and hide container tabs?
-  * Click hide
-    * \+ Number of tabs when clicked
-    * \+ Number of hidden containers when clicked
-  * Click show
-    * \+ Number of tabs when clicked
-    * \+ Number of shown containers when clicked
-* Do users move container tabs to new windows?
-  * Click move
-    * \+ Number of tabs when clicked
-  * Average number of container tabs when new window was clicked
-* How many containers do users have hidden at the same time? (when should we measure this? each time a container is hidden?)
-* Do users pin container tabs? (do we have existing Telemetry for pinning?)
-* Do users visit more pages in container tabs than non-container tabs?
-
-### Follow-up Questions
-
-What are some follow-up questions we anticipate we will ask based on any of the
-above answers/data?
-
-* What is the average lifespan of a container tab? Is that longer or shorter than a regular tab? (if we don't have data on the latter, the former probably isn't worth gathering data on since we will have nothing to compare it to).
-
-## Data Collection
-
-### Server Side
-There is currently no server side component to Containers.
-
-### Client Side
-Containers will use Test Pilot Telemetry with no batching of data.  Details
-of when pings are sent are below, along with examples of the `payload` portion
-of a `testpilottest` telemetry ping for each scenario.
-
-* The user clicks on a container name to open a tab in that container
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "clickedContainerTabCount": <number-of-tabs-in-the-container>,
-    "event": "open-tab",
-    "eventSource": ["tab-bar"|"pop-up"|"file-menu"]
-  }
-```
-
-* The user clicks "Edit Containers" in the pop-up
-
-```js
-  {
-    "uuid": <uuid>,
-    "event": "edit-containers"
-  }
-```
-
-* The user clicks OK after clicking on a container edit icon in the pop-up
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "event": "edit-container"
-  }
-```
-
-* The user clicks OK after clicking on a container delete icon in the pop-up
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "event": "delete-container"
-  }
-```
-
-* The user clicks OK after clicking to add a container in the pop-up
-
-```js
-  {
-    "uuid": <uuid>,
-    "event": "add-container"
-  }
-```
-
-* The user clicks the sort button/icon in the pop-up
-
-```js
-  {
-    "uuid": <uuid>,
-    "event": "sort-tabs",
-    "shownContainersCount": <number-of-containers-with-tabs-shown>,
-    "totalContainerTabsCount": <number-of-all-container-tabs>,
-    "totalNonContainerTabsCount": <number-of-all-non-container-tabs>
-  }
-```
-
-* The user clicks "Hide these container tabs" in the popup
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "clickedContainerTabCount": <number-of-tabs-in-the-container>,
-    "event": "hide-tabs",
-    "hiddenContainersCount": <number-of-containers-with-tabs-hidden>,
-    "shownContainersCount": <number-of-containers-with-tabs-shown>,
-    "totalContainersCount": <number-of-containers-with-tabs-hidden-or-shown>
-  }
-```
-
-* The user clicks "Show these container tabs" in the popup
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "clickedContainerTabCount": <number-of-tabs-in-the-container>,
-    "event": "show-tabs",
-    "hiddenContainersCount": <number-of-containers-with-tabs-hidden>,
-    "shownContainersCount": <number-of-containers-with-tabs-shown>,
-    "totalContainersCount": <number-of-containers-with-tabs-hidden-or-shown>
-  }
-```
-
-* The user clicks "Move tabs to a new window" in the popup
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "clickedContainerTabCount": <number-of-tabs-in-the-container>,
-    "event": "move-tabs-to-window"
-  }
-```
-
-* When a user encounters the disabled "move" feature because of incompatible add-ons
-
-```js
-  {
-    "uuid": <uuid>,
-    "event": "incompatible-addons-detected"
-  }
-```
-
-* The user closes a tab
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "event": "page-requests-completed-per-tab",
-    "pageRequestCount": <pageRequestCount>
-  }
-```
-
-* The user goes idle
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "event": "page-requests-completed-per-activity",
-    "pageRequestCount": <pageRequestCount>
-  }
-```
-
-* The user chooses "Always Open in this Container" context menu option. (Note: We send two separate event names: one for assigning a site to a container, one for removing a site from a container.)
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "event": "[added|removed]-container-assignment"
-  }
-```
-
-* Firefox prompts the user to reload a site into a container after the user picked "Always Open in this Container".
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "event": "prompt-reload-page-in-container"
-  }
-```
-
-* The user clicks "Take me there" to reload a site into a container after the user picked "Always Open in this Container".
-
-```js
-  {
-    "uuid": <uuid>,
-    "event": "click-to-reload-page-in-container"
-  }
-```
-
-* Firefox automatically reloads a site into a container after the user picked "Always Open in this Container".
-
-```js
-  {
-    "uuid": <uuid>,
-    "userContextId": <userContextId>,
-    "event": "auto-reload-page-in-container"
-  }
-```
-
-### A Redshift schema for the payload:
-
-```lua
-local schema = {
---   column name                    field type   length  attributes   field name
-    {"uuid",                        "VARCHAR",   255,    nil,         "Fields[payload.uuid]"},
-    {"userContextId",               "INTEGER",   255,    nil,         "Fields[payload.userContextId]"},
-    {"clickedContainerTabCount",    "INTEGER",   255,    nil,         "Fields[payload.clickedContainerTabCount]"},
-    {"eventSource",                 "VARCHAR",   255,    nil,         "Fields[payload.eventSource]"},
-    {"event",                       "VARCHAR",   255,    nil,         "Fields[payload.event]"},
-    {"pageRequestCount",            "INTEGER",   255,    nil,         "Fields[payload.pageRequestCount]"}
-    {"hiddenContainersCount",       "INTEGER",   255,    nil,         "Fields[payload.hiddenContainersCount]"},
-    {"shownContainersCount",        "INTEGER",   255,    nil,         "Fields[payload.shownContainersCount]"},
-    {"totalContainersCount",        "INTEGER",   255,    nil,         "Fields[payload.totalContainersCount]"},
-    {"totalContainerTabsCount",     "INTEGER",   255,    nil,         "Fields[payload.totalContainerTabsCount]"},
-    {"totalNonContainerTabsCount",  "INTEGER",   255,    nil,         "Fields[payload.totalNonContainerTabsCount]"}
-}
-```
-
-### Valid data should be enforced on the server side:
-
-* `eventSource` should be one of `tab-bar`, `pop-up`, or `file-menu`.
-
-All Mozilla data is kept by default for 180 days and in accordance with our
-privacy policies.

install.rdf

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>@testpilot-containers</em:id>
+    <em:type>2</em:type>
+    <em:bootstrap>true</em:bootstrap>
+    <em:multiprocessCompatible>true</em:multiprocessCompatible>
+    <em:hasEmbeddedWebExtension>true</em:hasEmbeddedWebExtension>
+    <em:name>Multi-Account Containers</em:name>
+    <em:description>Containers helps you keep all the parts of your online life contained in different tabs. Custom labels and color-coded tabs help keep different activities — like online shopping, travel planning, or checking work email — separate.</em:description>
+    <em:targetApplication>
+      <Description>
+        <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> <!--Firefox-->
+        <em:minVersion>53.0</em:minVersion>
+        <em:maxVersion>*</em:maxVersion>
+      </Description>
+    </em:targetApplication>
+    <em:version>4.0.3</em:version>
+    <em:unpack>false</em:unpack>
+  </Description>
+</RDF>
+

package.json

@@ -1,8 +1,8 @@
 {
   "name": "testpilot-containers",
-  "title": "Containers Experiment",
-  "description": "Containers works by isolating cookie jars using separate origin-attributes defined visually by colored ‘Container Tabs’. This add-on is a modified version of the containers feature for Firefox Test Pilot.",
-  "version": "2.2.0",
+  "title": "Multi-Account Containers",
+  "description": "Containers helps you keep all the parts of your online life contained in different tabs. Custom labels and color-coded tabs help keep different activities — like online shopping, travel planning, or checking work email — separate.",
+  "version": "4.0.3",
   "author": "Andrea Marchesini, Luke Crouch and Jonathan Kingston",
   "bugs": {
     "url": "https://github.com/mozilla/testpilot-containers/issues"
@@ -12,27 +12,17 @@
     "addons-linter": "^0.15.14",
     "deploy-txp": "^1.0.7",
     "eslint": "^3.17.1",
-    "eslint-plugin-no-unescaped": "^1.1.0",
+    "eslint-plugin-no-unsanitized": "^2.0.0",
     "eslint-plugin-promise": "^3.4.0",
     "htmllint-cli": "^0.0.5",
     "jpm": "^1.2.2",
+    "json": "^9.0.6",
     "npm-run-all": "^4.0.0",
     "stylelint": "^7.9.0",
     "stylelint-config-standard": "^16.0.0",
-    "stylelint-order": "^0.3.0",
-    "testpilot-metrics": "^2.1.0"
+    "stylelint-order": "^0.3.0"
   },
-  "engines": {
-    "firefox": ">=51.0"
-  },
-  "permissions": {
-    "multiprocess": true
-  },
-  "hasEmbeddedWebExtension": true,
   "homepage": "https://github.com/mozilla/testpilot-containers#readme",
-  "keywords": [
-    "jetpack"
-  ],
   "license": "MPL-2.0",
   "main": "index.js",
   "repository": {
@@ -49,6 +39,5 @@
     "lint:js": "eslint .",
     "package": "npm run build && mv testpilot-containers.xpi addon.xpi",
     "test": "npm run lint"
-  },
-  "updateURL": "https://testpilot.firefox.com/files/@testpilot-containers/updates.json"
+  }
 }

testpilot-metrics.js

@@ -1,333 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-/**
- * Class that represents a metrics event broker. Events are sent to Google
- * Analytics if the `tid` parameter is set. Events are sent to Mozilla's
- * data pipeline via the Test Pilot add-on. No metrics code changes are
- * needed when the experiment is added to or removed from Test Pilot.
- * @constructor
- * @param {string} $0.id - addon ID, e.g. '@testpilot-addon'. See https://mdn.io/add_on_id.
- * @param {string} $0.version - addon version, e.g. '1.0.2'.
- * @param {string} [$0.uid] - unique identifier for a specific instance of an addon.
- * Optional, but required to send events to Google Analytics. Sent to Google Analytics
- * but not Mozilla services.
- * @param {string} [$0.tid] - Google Analytics tracking ID. Optional, but required
- * to send events to Google Analytics.
- * @param {string} [$0.type=webextension] - addon type. one of: 'webextension',
- * 'sdk', 'bootstrapped'.
- * @param {boolean} [$0.debug=false] - if true, enables logging. Note that this
- * value can be changed on a running instance, by modifying its `debug` property.
- * @throws {SyntaxError} If the required properties are missing, or if the
- * 'type' property is unrecognized.
- * @throws {Error} if initializing the transports fails.
- */
-function Metrics({id, version, uid, tid = null, type = 'webextension', debug = false}) {
-  if (!id) {
-    throw new SyntaxError(`'id' property is required.`);
-  } else if (!version) {
-    throw new SyntaxError(`'version' property is required.`);
-  } else if (tid && !uid) {
-    throw new SyntaxError(`'uid' property is required to send events to Google Analytics.`);
-  }
-
-  if (!['webextension', 'sdk', 'bootstrapped'].includes(type)) {
-    throw new SyntaxError(`'type' property must be one of: 'webextension', 'sdk', or 'bootstrapped'`);
-  }
-  Object.assign(this, {id, uid, version, tid, type, debug});
-
-  // The test pilot add-on uses its own nsIObserverService topic for sending
-  // pings to Telemetry. Otherwise, the topic is based on add-on type.
-  if (id === '@testpilot-addon') {
-    this.topic = 'testpilot';
-  } else if (type === 'webextension') {
-    this.topic = 'testpilot-telemetry';
-  } else {
-    this.topic = 'testpilottest';
-  }
-
-  // NOTE: order is important here. _initTransports uses console.log, which may
-  // not be available before _initConsole has run.
-  this._initConsole();
-  this._initTransports();
-
-  this.sendEvent = this.sendEvent.bind(this);
-
-  this._log(`Initialized topic to ${this.topic}`);
-  if (!tid) {
-    this._log(`Google Analytics disabled: 'tid' value not passed to constructor.`);
-  } else {
-    this._log(`Google Analytics enabled for Tracking ID ${tid}.`);
-  }
-  this._log('Constructor finished successfully.');
-}
-Metrics.prototype = {
-  /**
-   * Sends an event to the Mozilla data pipeline (and Google Analytics, if
-   * a `tid` was passed to the constructor). Note: to avoid breaking callers,
-   * if sending the event fails, no Errors will be thrown. Instead, the message
-   * will be silently dropped, and, if debug mode is enabled, an error will be
-   * logged to the Browser Console.
-   *
-   * If you want to pass extra fields to GA, or use a GA hit type other than
-   * `Event`, you can transform the output data object yourself using the
-   * `transform` parameter. You will need to add Custom Dimensions to GA for any
-   * extra fields: https://support.google.com/analytics/answer/2709828. Note
-   * that, by convention, the `variant` argument is mapped to the first Custom
-   * Dimension (`cd1`) when constructing the GA Event hit.
-   *
-   * Note: the data object format is currently different for each experiment,
-   * and should be defined based on the result of conversations with the Mozilla
-   * data team.
-   *
-   * A suggested default format is:
-   * @param {string} [$0.method] - What is happening? e.g. `click`
-   * @param {string} [$0.object] - What is being affected? e.g. `home-button-1`
-   * @param {string} [$0.category=interactions] - If you want to add a category
-   * for easy reporting later. e.g. `mainmenu`
-   * @param {string} [$0.variant=null] - An identifying string if you're running
-   * different variants. e.g. `cohort-A`
-   * @param {function} [transform] - Transform function used to alter the
-   * parameters sent to GA. The `transform` function signature is
-   * `transform(input, output)`, where `input` is the object passed to
-   * `sendEvent` (excluding `transform`), and `output` is the default GA
-   * object generated by the `_gaTransform` method. The `transform` function
-   * should return an object whose keys are GA Measurement Protocol parameters.
-   * The returned object will be form encoded and sent to GA.
-   */
-  sendEvent: function(params = {}, transform) {
-    const args = this._clone(params);
-    args.object = params.object || null;
-    args.category = params.category || 'interactions';
-    args.variant = params.variant || null;
-
-    this._log(`sendEvent called with method = ${args.method}, object = ${args.object}, category = ${args.category}, variant = ${args.variant}.`);
-
-    const clientData = this._clone(args);
-    const gaData = this._clone(args);
-    if (!clientData) {
-      this._error(`Unable to process data object. Dropping packet.`);
-      return;
-    }
-    this._sendToClient(clientData);
-
-    if (this.tid && this.uid) {
-      const defaultEvent = this._gaTransform(gaData);
-
-      let userEvent;
-      if (transform) {
-        userEvent = transform.call(null, gaData, defaultEvent);
-      }
-
-      this._gaSend(userEvent || defaultEvent);
-    }
-  },
-
-  /**
-   * Clone a data object by serializing / deserializing it.
-   * @private
-   * @param {object} o - Object to be cloned.
-   * @returns A clone of the object, or `null` if cloning failed.
-   */
-  _clone: function(o) {
-    let cloned;
-    try {
-      cloned = JSON.parse(JSON.stringify(o));
-    } catch (ex) {
-      this._error(`Unable to clone object: ${ex}.`);
-      return null;
-    }
-    return cloned;
-  },
-
-  /**
-   * Sends an event to the Mozilla data pipeline via the Test Pilot add-on.
-   * Uses BroadcastChannel for WebExtensions, and nsIObserverService for other
-   * add-on types.
-   * @private
-   * @param {object} params - Entire object sent to `sendEvent`.
-   */
-  _sendToClient: function(params) {
-    if (this.type === 'webextension') {
-      this._channel.postMessage(params);
-      this._log(`Sent client message via postMessage: ${params}`);
-    } else {
-      let stringified;
-
-      try {
-        stringified = JSON.stringify(params);
-      } catch(ex) {
-        this._error(`Unable to serialize metrics event: ${ex}`);
-        return;
-      }
-
-      const subject = {
-        wrappedJSObject: {
-          observersModuleSubjectWrapper: true,
-          object: this.id
-        }
-      };
-
-      try {
-        Services.obs.notifyObservers(subject, 'testpilot::send-metric', stringified);
-        this._log(`Sent client message via nsIObserverService: ${stringified}`);
-      } catch (ex) {
-        this._error(`Failed to send nsIObserver client ping: ${ex}`);
-        return;
-      }
-    }
-  },
-
-   /**
-   * Transforms `sendEvent()` arguments into a Google Analytics `Event` hit.
-   * @private
-   * @param {string} method - see `sendEvent` docs
-   * @param {string} [object] - see `sendEvent` docs
-   * @param {string} category - see `sendEvent` docs. Note that `category` is
-   * required here, assuming the default value was filled in by `sendEvent()`.
-   * @param {string} variant - see `sendEvent` docs. Note that `variant` is
-   * required here, assuming the default value was filled in by `sendEvent()`.
-   */
-  _gaTransform: function({method, object, category, variant}) {
-    const data = {
-      v: 1,
-      an: this.id,
-      av: this.version,
-      tid: this.tid,
-      uid: this.uid,
-      t: 'event',
-      ec: category,
-      ea: method
-    };
-    if (object) {
-      data.el = object;
-    }
-    if (variant) {
-      data.cd1 = variant;
-    }
-    return data;
-  },
-
-  /**
-   * Encodes and sends an event message to Google Analytics.
-   * @private
-   * @param {object} msg - An object whose keys correspond to parameters in the
-   * Google Analytics Measurement Protocol.
-   */
-  _gaSend: function(msg) {
-    const encoded = this._formEncode(msg);
-    const GA_URL = 'https://ssl.google-analytics.com/collect';
-    if (this.type === 'webextension') {
-      navigator.sendBeacon(GA_URL, encoded);
-    } else {
-      // SDK and bootstrapped types might not have a window reference, so get
-      // the sendBeacon DOM API from the hidden window.
-      Services.appShell.hiddenDOMWindow.navigator.sendBeacon(GA_URL, encoded);
-    }
-    this._log(`Sent GA message: ${encoded}`);
-  },
-
-  /**
-   * URL encodes an object. Encodes spaces as '%20', not '+', following the
-   * GA docs.
-   *
-   * @example
-   * // returns 'a=b&foo=b%20ar'
-   * metrics._formEncode({a: 'b', foo: 'b ar'});
-   * @private
-   * @param {Object} obj - Any JS object
-   * @returns {string}
-   */
-  _formEncode: function(obj) {
-    const params = [];
-    if (!obj) { return ''; }
-    Object.keys(obj).forEach(item => {
-      const encoded = encodeURIComponent(item) + '=' + encodeURIComponent(obj[item]);
-      params.push(encoded);
-    });
-    return params.join('&');
-  },
-
-  /**
-   * Initializes transports used for sending messages. For WebExtensions,
-   * creates a `BroadcastChannel` (transport for client pings). WebExtensions
-   * use navigator.sendBeacon for GA transport, and they always have access
-   * to DOM APIs, so there's no setup work required. For other types, loads
-   * `Services.jsm`, which exposes the nsIObserverService (transport for client
-   * pings), and exposes the navigator.sendBeacon API (GA transport) via the
-   * appShell service's hidden window.
-   * @private
-   * @throws {Error} if transport setup unexpectedly fails
-   */
-  _initTransports: function() {
-    if (this.type === 'webextension') {
-      try {
-        this._channel = new BroadcastChannel(this.topic);
-      } catch(ex) {
-        throw new Error(`Unable to create BroadcastChannel: ${ex}`);
-      }
-    } else if (this.type === 'sdk') {
-      try {
-        const { Cu } = require('chrome');
-        Cu.import('resource://gre/modules/Services.jsm');
-      } catch(ex) {
-        throw new Error(`Unable to load Services.jsm: ${ex}`);
-      }
-    } else { /* this.type === 'bootstrapped' */
-      try {
-        Components.utils.import('resource://gre/modules/Services.jsm');
-      } catch(ex) {
-        throw new Error(`Unable to load Services.jsm: ${ex}`);
-      }
-    }
-    this._log('Successfully initialized transports.');
-  },
-
-  /**
-   * Initializes a console for 'bootstrapped' add-ons.
-   * @private
-   */
-  _initConsole: function() {
-    if (this.type === 'bootstrapped') {
-      try {
-        Components.utils.import('resource://gre/modules/Console.jsm');
-        this._log('Successfully initialized console.');
-      } catch(ex) {
-        throw new Error(`Unable to initialize console: ${ex}`);
-      }
-    }
-  },
-
-  /**
-   * Logs messages to the console. Only enabled if `this.debug` is truthy.
-   * @private
-   * @param {string} msg - A message
-   */
-  _log: function(msg) {
-    if (this.debug) {
-      console.log(msg); // eslint-disable-line no-console
-    }
-  },
-
-  /**
-   * Logs errors to the console. Only enabled if `this.debug` is truthy.
-   * @private
-   * @param {string} msg - An error message
-   */
-  _error: function(msg) {
-    if (this.debug) {
-      console.error(msg); // eslint-disable-line no-console
-    }
-  }
-};
-
-// WebExtensions don't support CommonJS module style, so 'module' might not be
-// defined.
-if (typeof module !== 'undefined') {
-  module.exports = Metrics;
-}
-
-// Export the Metrics constructor in Gecko JSM style, for legacy addons
-// that use the JSM loader. See also: https://mdn.io/jsm/using
-const EXPORTED_SYMBOLS = ['Metrics']; // eslint-disable-line no-unused-vars

webextension/background.js

@@ -1,473 +0,0 @@
-const assignManager = {
-  CLOSEABLE_WINDOWS: new Set([
-    "about:startpage",
-    "about:newtab",
-    "about:home",
-    "about:blank"
-  ]),
-  MENU_ASSIGN_ID: "open-in-this-container",
-  MENU_REMOVE_ID: "remove-open-in-this-container",
-  storageArea: {
-    area: browser.storage.local,
-
-    getSiteStoreKey(pageUrl) {
-      const url = new window.URL(pageUrl);
-      const storagePrefix = "siteContainerMap@@_";
-      return `${storagePrefix}${url.hostname}`;
-    },
-
-    get(pageUrl) {
-      const siteStoreKey = this.getSiteStoreKey(pageUrl);
-      return new Promise((resolve, reject) => {
-        this.area.get([siteStoreKey]).then((storageResponse) => {
-          if (storageResponse && siteStoreKey in storageResponse) {
-            resolve(storageResponse[siteStoreKey]);
-          }
-          resolve(null);
-        }).catch((e) => {
-          reject(e);
-        });
-      });
-    },
-
-    set(pageUrl, data) {
-      const siteStoreKey = this.getSiteStoreKey(pageUrl);
-      return this.area.set({
-        [siteStoreKey]: data
-      });
-    },
-
-    remove(pageUrl) {
-      const siteStoreKey = this.getSiteStoreKey(pageUrl);
-      return this.area.remove([siteStoreKey]);
-    },
-
-    deleteContainer(userContextId) {
-      const removeKeys = [];
-      this.area.get().then((siteConfigs) => {
-        Object.keys(siteConfigs).forEach((key) => {
-          // For some reason this is stored as string... lets check them both as that
-          if (String(siteConfigs[key].userContextId) === String(userContextId)) {
-            removeKeys.push(key);
-          }
-        });
-        this.area.remove(removeKeys);
-      }).catch((e) => {
-        throw e;
-      });
-    }
-  },
-
-  init() {
-    browser.runtime.onMessage.addListener((neverAskMessage) => {
-      const pageUrl = neverAskMessage.pageUrl;
-      if (neverAskMessage.neverAsk === true) {
-        // If we have existing data and for some reason it hasn't been deleted etc lets update it
-        this.storageArea.get(pageUrl).then((siteSettings) => {
-          if (siteSettings) {
-            siteSettings.neverAsk = true;
-            this.storageArea.set(pageUrl, siteSettings);
-          }
-        }).catch((e) => {
-          throw e;
-        });
-      }
-    });
-
-    browser.contextMenus.onClicked.addListener((info, tab) => {
-      const userContextId = this.getUserContextIdFromCookieStore(tab);
-      // Mapping ${URL(info.pageUrl).hostname} to ${userContextId}
-      if (userContextId) {
-        let actionName;
-        let storageAction;
-        if (info.menuItemId === this.MENU_ASSIGN_ID) {
-          actionName = "added";
-          storageAction = this.storageArea.set(info.pageUrl, {
-            userContextId,
-            neverAsk: false
-          });
-        } else {
-          actionName = "removed";
-          storageAction = this.storageArea.remove(info.pageUrl);
-        }
-        storageAction.then(() => {
-          browser.notifications.create({
-            type: "basic",
-            title: "Containers",
-            message: `Successfully ${actionName} site to always open in this container`,
-            iconUrl: browser.extension.getURL("/img/onboarding-1.png")
-          });
-          browser.runtime.sendMessage({
-            method: "sendTelemetryPayload",
-            event: `${actionName}-container-assignment`,
-            userContextId: userContextId,
-          });
-          this.calculateContextMenu(tab);
-        }).catch((e) => {
-          throw e;
-        });
-      }
-    });
-
-    // Before a request is handled by the browser we decide if we should route through a different container
-    browser.webRequest.onBeforeRequest.addListener((options) => {
-      if (options.frameId !== 0 || options.tabId === -1) {
-        return {};
-      }
-      return Promise.all([
-        browser.tabs.get(options.tabId),
-        this.storageArea.get(options.url)
-      ]).then(([tab, siteSettings]) => {
-        const userContextId = this.getUserContextIdFromCookieStore(tab);
-        if (!siteSettings
-            || userContextId === siteSettings.userContextId
-            || tab.incognito) {
-          return {};
-        }
-
-        this.reloadPageInContainer(options.url, siteSettings.userContextId, tab.index + 1, siteSettings.neverAsk);
-        this.calculateContextMenu(tab);
-
-        /* Removal of existing tabs:
-           We aim to open the new assigned container tab / warning prompt in it's own tab:
-             - As the history won't span from one container to another it seems most sane to not try and reopen a tab on history.back()
-             - When users open a new tab themselves we want to make sure we don't end up with three tabs as per: https://github.com/mozilla/testpilot-containers/issues/421
-           If we are coming from an internal url that are used for the new tab page (CLOSEABLE_WINDOWS), we can safely close as user is unlikely losing history
-           Detecting redirects on "new tab" opening actions is pretty hard as we don't get tab history:
-           - Redirects happen from Short URLs and tracking links that act as a gateway
-           - Extensions don't provide a way to history crawl for tabs, we could inject content scripts to do this
-               however they don't run on about:blank so this would likely be just as hacky.
-           We capture the time the tab was created and close if it was within the timeout to try to capture pages which haven't had user interaction or history.
-        */
-        if (this.CLOSEABLE_WINDOWS.has(tab.url)
-            || (messageHandler.lastCreatedTab
-            && messageHandler.lastCreatedTab.id === tab.id)) {
-          browser.tabs.remove(tab.id);
-        }
-        return {
-          cancel: true,
-        };
-      }).catch((e) => {
-        throw e;
-      });
-    },{urls: ["<all_urls>"], types: ["main_frame"]}, ["blocking"]);
-  },
-
-
-  deleteContainer(userContextId) {
-    this.storageArea.deleteContainer(userContextId);
-  },
-
-  getUserContextIdFromCookieStore(tab) {
-    if (!("cookieStoreId" in tab)) {
-      return false;
-    }
-    const cookieStore = tab.cookieStoreId;
-    const container = cookieStore.replace("firefox-container-", "");
-    if (container !== cookieStore) {
-      return container;
-    }
-    return false;
-  },
-
-  isTabPermittedAssign(tab) {
-    // Ensure we are not an important about url
-    // Ensure we are not in incognito mode
-    const url = new URL(tab.url);
-    if (url.protocol === "about:"
-        || tab.incognito) {
-      return false;
-    }
-    return true;
-  },
-
-  calculateContextMenu(tab) {
-    // There is a focus issue in this menu where if you change window with a context menu click
-    // you get the wrong menu display because of async
-    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1215376#c16
-    // We also can't change for always private mode
-    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1352102
-    const cookieStore = this.getUserContextIdFromCookieStore(tab);
-    browser.contextMenus.remove(this.MENU_ASSIGN_ID);
-    browser.contextMenus.remove(this.MENU_REMOVE_ID);
-    // Ensure we have a cookieStore to assign to
-    if (cookieStore
-        && this.isTabPermittedAssign(tab)) {
-      this.storageArea.get(tab.url).then((siteSettings) => {
-        // ✓ This is to mitigate https://bugzilla.mozilla.org/show_bug.cgi?id=1351418
-        let prefix = "   "; // Alignment of non breaking space, unknown why this requires so many spaces to align with the tick
-        let menuId = this.MENU_ASSIGN_ID;
-        if (siteSettings) {
-          prefix = "✓";
-          menuId = this.MENU_REMOVE_ID;
-        }
-        browser.contextMenus.create({
-          id: menuId,
-          title: `${prefix} Always Open in This Container`,
-          checked: true,
-          contexts: ["all"],
-        });
-      }).catch((e) => {
-        throw e;
-      });
-    }
-  },
-
-  reloadPageInContainer(url, userContextId, index, neverAsk = false) {
-    const loadPage = browser.extension.getURL("confirm-page.html");
-    // If the user has explicitly checked "Never Ask Again" on the warning page we will send them straight there
-    if (neverAsk) {
-      browser.tabs.create({url, cookieStoreId: `firefox-container-${userContextId}`, index});
-      browser.runtime.sendMessage({
-        method: "sendTelemetryPayload",
-        event: "auto-reload-page-in-container",
-        userContextId: userContextId,
-      });
-    } else {
-      browser.runtime.sendMessage({
-        method: "sendTelemetryPayload",
-        event: "prompt-to-reload-page-in-container",
-        userContextId: userContextId,
-      });
-      const confirmUrl = `${loadPage}?url=${url}`;
-      browser.tabs.create({url: confirmUrl, cookieStoreId: `firefox-container-${userContextId}`, index}).then(() => {
-        // We don't want to sync this URL ever nor clutter the users history
-        browser.history.deleteUrl({url: confirmUrl});
-      }).catch((e) => {
-        throw e;
-      });
-    }
-  }
-};
-
-const messageHandler = {
-  // After the timer completes we assume it's a tab the user meant to keep open
-  // We use this to catch redirected tabs that have just opened
-  // If this were in platform we would change how the tab opens based on "new tab" link navigations such as ctrl+click
-  LAST_CREATED_TAB_TIMER: 2000,
-
-  init() {
-    // Handles messages from index.js
-    const port = browser.runtime.connect();
-    port.onMessage.addListener(m => {
-      switch (m.type) {
-      case "lightweight-theme-changed":
-        themeManager.update(m.message);
-        break;
-      case "delete-container":
-        assignManager.deleteContainer(m.message.userContextId);
-        break;
-      default:
-        throw new Error(`Unhandled message type: ${m.message}`);
-      }
-    });
-
-    browser.tabs.onCreated.addListener((tab) => {
-      // This works at capturing the tabs as they are created
-      // However we need onFocusChanged and onActivated to capture the initial tab
-      if (tab.id === -1) {
-        return {};
-      }
-      tabPageCounter.initTabCounter(tab);
-    });
-
-    browser.tabs.onRemoved.addListener((tabId) => {
-      if (tabId === -1) {
-        return {};
-      }
-      tabPageCounter.sendTabCountAndDelete(tabId);
-    });
-
-    browser.tabs.onActivated.addListener((info) => {
-      browser.tabs.get(info.tabId).then((tab) => {
-        tabPageCounter.initTabCounter(tab);
-        assignManager.calculateContextMenu(tab);
-      }).catch((e) => {
-        throw e;
-      });
-    });
-
-    browser.windows.onFocusChanged.addListener((windowId) => {
-      browser.tabs.query({active: true, windowId}).then((tabs) => {
-        if (tabs && tabs[0]) {
-          tabPageCounter.initTabCounter(tabs[0]);
-          assignManager.calculateContextMenu(tabs[0]);
-        }
-      }).catch((e) => {
-        throw e;
-      });
-    });
-
-    browser.idle.onStateChanged.addListener((newState) => {
-      browser.tabs.query({}).then(tabs => {
-        for (let tab of tabs) { // eslint-disable-line prefer-const
-          if (newState === "idle") {
-            tabPageCounter.sendTabCountAndDelete(tab.id, "user-went-idle");
-          } else if (newState === "active" && tab.active) {
-            tabPageCounter.initTabCounter(tab);
-          }
-        }
-      }).catch(e => {
-        throw e;
-      });
-    });
-
-    browser.webRequest.onCompleted.addListener((details) => {
-      if (details.frameId !== 0 || details.tabId === -1) {
-        return {};
-      }
-
-      browser.tabs.get(details.tabId).then((tab) => {
-        tabPageCounter.incrementTabCount(tab);
-        assignManager.calculateContextMenu(tab);
-      }).catch((e) => {
-        throw e;
-      });
-    }, {urls: ["<all_urls>"], types: ["main_frame"]});
-
-    // lets remember the last tab created so we can close it if it looks like a redirect
-    browser.tabs.onCreated.addListener((details) => {
-      this.lastCreatedTab = details;
-      setTimeout(() => {
-        this.lastCreatedTab = null;
-      }, this.LAST_CREATED_TAB_TIMER);
-    });
-
-  }
-};
-
-const themeManager = {
-  existingTheme: null,
-  init() {
-    this.check();
-  },
-  setPopupIcon(theme) {
-    let icons = {
-      16: "img/container-site-d-24.png",
-      32: "img/container-site-d-48.png"
-    };
-    if (theme === "firefox-compact-dark@mozilla.org") {
-      icons = {
-        16: "img/container-site-w-24.png",
-        32: "img/container-site-w-48.png"
-      };
-    }
-    browser.browserAction.setIcon({
-      path: icons
-    });
-  },
-  check() {
-    browser.runtime.sendMessage({
-      method: "getTheme"
-    }).then((theme) => {
-      this.update(theme);
-    }).catch(() => {
-      throw new Error("Unable to get theme");
-    });
-  },
-  update(theme) {
-    if (this.existingTheme !== theme) {
-      this.setPopupIcon(theme);
-      this.existingTheme = theme;
-    }
-  }
-};
-
-const tabPageCounter = {
-  counters: {},
-
-  initTabCounter(tab) {
-    if (tab.id in this.counters) {
-      if (!("activity" in this.counters[tab.id])) {
-        this.counters[tab.id].activity = {
-          "cookieStoreId": tab.cookieStoreId,
-          "pageRequests": 0
-        };
-      }
-      if (!("tab" in this.counters[tab.id])) {
-        this.counters[tab.id].tab = {
-          "cookieStoreId": tab.cookieStoreId,
-          "pageRequests": 0
-        };
-      }
-    } else {
-      this.counters[tab.id] = {};
-      this.counters[tab.id].tab = {
-        "cookieStoreId": tab.cookieStoreId,
-        "pageRequests": 0
-      };
-      this.counters[tab.id].activity = {
-        "cookieStoreId": tab.cookieStoreId,
-        "pageRequests": 0
-      };
-    }
-  },
-
-  sendTabCountAndDelete(tabId, why = "user-closed-tab") {
-    if (!(this.counters[tabId])) {
-      return;
-    }
-    if (why === "user-closed-tab" && this.counters[tabId].tab) {
-      browser.runtime.sendMessage({
-        method: "sendTelemetryPayload",
-        event: "page-requests-completed-per-tab",
-        userContextId: this.counters[tabId].tab.cookieStoreId,
-        pageRequestCount: this.counters[tabId].tab.pageRequests
-      });
-      // When we send the ping because the user closed the tab,
-      // delete both the 'tab' and 'activity' counters
-      delete this.counters[tabId];
-    } else if (why === "user-went-idle" && this.counters[tabId].activity) {
-      browser.runtime.sendMessage({
-        method: "sendTelemetryPayload",
-        event: "page-requests-completed-per-activity",
-        userContextId: this.counters[tabId].activity.cookieStoreId,
-        pageRequestCount: this.counters[tabId].activity.pageRequests
-      });
-      // When we send the ping because the user went idle,
-      // only reset the 'activity' counter
-      this.counters[tabId].activity = {
-        "cookieStoreId": this.counters[tabId].tab.cookieStoreId,
-        "pageRequests": 0
-      };
-    }
-  },
-
-  incrementTabCount(tab) {
-    this.counters[tab.id].tab.pageRequests++;
-    this.counters[tab.id].activity.pageRequests++;
-  }
-};
-
-assignManager.init();
-themeManager.init();
-// Lets do this last as theme manager did a check before connecting before
-messageHandler.init();
-
-browser.runtime.sendMessage({
-  method: "getPreference",
-  pref: "browser.privatebrowsing.autostart"
-}).then(pbAutoStart => {
-
-  // We don't want to disable the addon if we are in auto private-browsing.
-  if (!pbAutoStart) {
-    browser.tabs.onCreated.addListener(tab => {
-      if (tab.incognito) {
-        disableAddon(tab.id);
-      }
-    });
-
-    browser.tabs.query({}).then(tabs => {
-      for (let tab of tabs) { // eslint-disable-line prefer-const
-        if (tab.incognito) {
-          disableAddon(tab.id);
-        }
-      }
-    }).catch(() => {});
-  }
-}).catch(() => {});
-
-function disableAddon(tabId) {
-  browser.browserAction.disable(tabId);
-  browser.browserAction.setTitle({ tabId, title: "Containers disabled in Private Browsing Mode" });
-}

webextension/confirm-page.html

@@ -1,33 +1,36 @@
 <html>
 <head>
   <meta http-equiv="content-type" content="text/html; charset=utf-8">
-  <title>Containers confirm navigation</title>
+  <title>Multi-Account Containers Confirm Navigation</title>
   <link xmlns="http://www.w3.org/1999/xhtml" rel="stylesheet" href="chrome://browser/skin/aboutNetError.css" type="text/css" media="all" />
   <link rel="stylesheet" href="/css/confirm-page.css" />
 </head>
 <body>
   <main>
     <div class="title">
-      <h1 class="title-text">Should we open this in your container?</h1>
+      <h1 class="title-text">Open this site in your assigned container?</h1>
     </div>
     <form id="redirect-form">
       <p>
-        Looks like you requested:
+        You asked <dfn id="browser-name" title="Thanks for trying out Containers. Sorry we may have got your browser name wrong. #FxNightly" >Firefox</dfn> to always open <dfn class="container-name"></dfn> for this site:<br />
       </p>
       <div id="redirect-url"></div>
-      <p>
-        You asked <dfn id="browser-name" title="Thanks for trying out Containers. Sorry we may have got your browser name wrong. #FxNightly" >Firefox</dfn> to always open <dfn id="redirect-site"></dfn> in <dfn>this</dfn> type of container. Would you like to proceed?<br />
-      </p>
+      <p>Would you still like to open in this current container?</p>
       <br />
       <br />
-      <input id="never-ask" type="checkbox" /><label for="never-ask">Remember my decision for this site</label>
+      <label for="never-ask" class="check-label">
+        <input id="never-ask" type="checkbox" />
+        Remember my decision for this site
+      </label>
       <br />
       <div class="button-container">
-        <button id="confirm" class="button primary" autofocus>Take me there</button>
+        <button id="deny" class="button">Open in <dfn id="current-container-name">Current</dfn> Container</button>
+        <button id="confirm" class="button primary" autofocus>Open in <dfn class="container-name"></dfn> Container</button>
       </div>
     </form>
   </main>
 
+  <script src="js/utils.js"></script>
   <script src="js/confirm-page.js"></script>
 </body>
 </html>

webextension/css/confirm-page.css

@@ -4,11 +4,21 @@
 }
 
 main {
-  background: url(/img/onboarding-1.png) no-repeat;
+  background: url(/img/onboarding-4.png) no-repeat;
   background-position: -10px -15px;
-  background-size: 285px;
-  margin-inline-start: -285px;
-  padding-inline-start: 285px;
+  background-size: 300px;
+  margin-inline-start: -350px;
+  padding-inline-start: 350px;
+}
+
+.container-name {
+  font-weight: bold;
+}
+
+button .container-name,
+#current-container-name {
+  font-weight: bold;
+  text-transform: capitalize;
 }
 
 @media only screen and (max-width: 1300px) {
@@ -36,6 +46,33 @@ html {
   word-break: break-all;
 }
 
+#redirect-url {
+  background: #efefef;
+  border-radius: 2px;
+  line-height: 1.5;
+  padding-block-end: 0.5rem;
+  padding-block-start: 0.5rem;
+  padding-inline-end: 0.5rem;
+  padding-inline-start: 0.5rem;
+}
+
+#redirect-url img {
+  block-size: 16px;
+  inline-size: 16px;
+  margin-inline-end: 6px;
+  offset-block-start: 3px;
+  position: relative;
+}
+
 dfn {
   font-style: normal;
 }
+
+.button-container > button {
+  min-inline-size: 240px;
+}
+
+.check-label {
+  align-items: center;
+  display: flex;
+}

webextension/css/content.css

@@ -0,0 +1,27 @@
+.container-notification {
+  align-items: center;
+  background: #efefef;
+  color: #003f07;
+  display: flex;
+  font: 12px sans-serif;
+  inline-size: 100vw;
+  justify-content: start;
+  offset-block-start: 0;
+  offset-inline-start: 0;
+  padding-block-end: 8px;
+  padding-block-start: 8px;
+  padding-inline-end: 8px;
+  padding-inline-start: 8px;
+  position: fixed;
+  text-align: start;
+  transform: translateY(-100%);
+  transition: transform 0.3s cubic-bezier(0.07, 0.95, 0, 1) 0.3s;
+  z-index: 999999999999;
+}
+
+.container-notification img {
+  block-size: 16px;
+  display: inline-block;
+  inline-size: 16px;
+  margin-inline-end: 3px;
+}

webextension/css/popup.css

@@ -1,11 +1,56 @@
 /* General Rules and Resets */
+* {
+  font-size: inherit;
+  margin-block-end: 0;
+  margin-block-start: 0;
+  margin-inline-end: 0;
+  margin-inline-start: 0;
+  padding-block-end: 0;
+  padding-block-start: 0;
+  padding-inline-end: 0;
+  padding-inline-start: 0;
+}
+
+html {
+  background-color: #fefefe;
+  box-sizing: border-box;
+  font-size: 12px;
+}
+
 body {
+  font-family: Roboto, Noto, "San Francisco", Ubuntu, "Segoe UI", "Fira Sans", message-box, Arial, sans-serif;
   inline-size: 300px;
   max-inline-size: 300px;
 }
 
-html {
-  box-sizing: border-box;
+:root {
+  --primary-action-color: #248aeb;
+  --title-text-color: #000;
+  --text-normal-color: #4a4a4a;
+  --text-heading-color: #000;
+
+  /* calculated from 12px */
+  --font-size-heading: 1.33rem; /* 16px */
+  --block-line-space-size: 0.5rem; /* 6px */
+  --inline-item-space-size: 0.5rem; /* 6px */
+  --block-line-separation-size: 0.33rem; /* 10px */
+  --inline-icon-space-size: 0.833rem; /* 10px */
+
+  /* Use for url and icon size */
+  --block-url-label-size: 2rem; /* 24px */
+  --inline-start-size: 1.66rem; /* 20px */
+  --inline-button-size: 5.833rem; /* 70px */
+  --icon-size: 1.166rem; /* 14px */
+
+  --small-text-size: 0.833rem; /* 10px */
+  --small-radius: 3px;
+  --icon-button-size: calc(calc(var(--block-line-separation-size) * 2) + 1.66rem); /* 20px */
+}
+
+@media (min-resolution: 1dppx) {
+  html {
+    font-size: 14px;
+  }
 }
 
 *,
@@ -14,6 +59,13 @@ html {
   box-sizing: inherit;
 }
 
+form {
+  margin-block-end: 0;
+  margin-block-start: 0;
+  margin-inline-end: 0;
+  margin-inline-start: 0;
+}
+
 table {
   border: 0;
   border-spacing: 0;
@@ -30,11 +82,27 @@ table {
 }
 
 .scrollable {
+  border-block-start: 1px solid #f1f1f1;
   inline-size: 100%;
   max-block-size: 400px;
   overflow: auto;
 }
 
+.offpage {
+  opacity: 0;
+}
+
+[hidden] {
+  display: none !important;
+}
+
+/* Effect borrowed from tabs in Firefox, ensure that the element flexes to the full width */
+.truncate-text {
+  mask-image: linear-gradient(to left, transparent, black 1em);
+  overflow: hidden;
+  white-space: nowrap;
+}
+
 /* Color and icon helpers */
 [data-identity-color="blue"] {
   --identity-tab-color: #37adff;
@@ -51,6 +119,11 @@ table {
   --identity-icon-color: #51cd00;
 }
 
+[data-identity-color="grey"] {
+  /* Only used for the edit panel */
+  --identity-icon-color: #616161;
+}
+
 [data-identity-color="yellow"] {
   --identity-tab-color: #ffcb00;
   --identity-icon-color: #ffcb00;
@@ -124,20 +197,43 @@ table {
   --identity-icon: url("/img/usercontext.svg#chill");
 }
 
+#current-tab [data-identity-icon="default-tab"] {
+  background: center center no-repeat url("/img/blank-tab.svg");
+  fill: currentColor;
+}
+
 /* Buttons */
+.button {
+  color: black;
+}
+
 .button.primary {
   background-color: #0996f8;
   color: white;
 }
 
-.button.primary:hover {
+.button.primary:hover,
+.button.primary:focus {
   background-color: #0675d3;
 }
 
-.button.secondary:hover {
+.button.secondary:hover,
+.button.secondary:focus {
   background-color: rgba(0, 0, 0, 0.05);
 }
 
+/* Text links with actions */
+
+.action-link:link {
+  color: var(--primary-action-color);
+  text-decoration: none;
+}
+
+.action-link:active,
+.action-link:hover {
+  text-decoration: underline;
+}
+
 /* Panels keep everything togethert */
 .panel {
   display: flex;
@@ -181,7 +277,7 @@ table {
 .column-panel-content .button,
 .panel-footer .button {
   align-items: center;
-  block-size: 54px;
+  block-size: 100%;
   display: flex;
   flex: 1;
   justify-content: center;
@@ -198,7 +294,8 @@ table {
   justify-content: center;
 }
 
-.panel-back-arrow:hover {
+.panel-back-arrow:hover,
+.panel-back-arrow:focus {
   background: #dedede;
 }
 
@@ -220,7 +317,7 @@ table {
 
 .onboarding-title {
   color: #43484e;
-  font-size: 16px;
+  font-size: var(--font-size-heading);
   margin-block-end: 0;
   margin-block-start: 0;
   margin-inline-end: 0;
@@ -229,7 +326,7 @@ table {
 }
 
 .onboarding p {
-  color: #4a4a4a;
+  color: var(--text-normal-color);
   font-size: 14px;
   margin-block-end: 16px;
   max-inline-size: 84%;
@@ -249,7 +346,8 @@ table {
   transition: background-color 75ms;
 }
 
-.onboarding-button:hover {
+.onboarding-button:hover,
+.onboarding-button:active {
   background-color: #0675d3;
 }
 
@@ -257,25 +355,38 @@ table {
 manage things like container crud */
 .pop-button {
   align-items: center;
-  block-size: 48px;
+  block-size: var(--icon-button-size);
+  cursor: pointer;
   display: flex;
-  flex: 0 0 48px;
+  flex: 0 0 var(--icon-button-size);
   justify-content: center;
 }
 
 .pop-button:hover,
+.pop-button:focus,
+.panel-footer-secondary:focus,
 .panel-footer-secondary:hover {
   background-color: rgba(0, 0, 0, 0.05);
 }
 
-.pop-button:active,
-.panel-footer-secondary:active {
+.pop-button:focus,
+.panel-footer-secondary:focus {
   background-color: rgba(0, 0, 0, 0.08);
 }
 
+.pop-button a,
+.panel-footer a,
+.panel-footer-secondary a {
+  text-decoration: none;
+}
+
 .pop-button-image {
   block-size: 20px;
   flex: 0 0 20px;
+  margin-block-end: auto;
+  margin-block-start: auto;
+  margin-inline-end: auto;
+  margin-inline-start: auto;
 }
 
 .pop-button-image-small {
@@ -287,20 +398,23 @@ manage things like container crud */
 .panel-header {
   align-items: center;
   block-size: 48px;
-  border-block-end: 1px solid #ebebeb;
   display: flex;
   justify-content: space-between;
 }
 
+.panel-header .usercontext-icon {
+  inline-size: var(--icon-button-size);
+}
+
 .column-panel-content .panel-header {
   flex: 0 0 48px;
   inline-size: 100%;
 }
 
 .panel-header-text {
-  color: #4a4a4a;
+  color: var(--text-normal-color);
   flex: 1;
-  font-size: 16px;
+  font-size: var(--font-size-heading);
   font-weight: normal;
   margin-block-end: 0;
   margin-block-start: 0;
@@ -312,6 +426,47 @@ manage things like container crud */
   padding-inline-start: 16px;
 }
 
+#container-panel .panel-header {
+  background-color: #efefef;
+  block-size: 26px;
+  font-size: 14px;
+}
+
+#container-panel .panel-header-text {
+  color: #727272;
+  font-size: 14px;
+  padding-block-end: 0;
+  padding-block-start: 0;
+  text-transform: uppercase;
+}
+
+.container-panel-controls {
+  display: flex;
+  justify-content: flex-end;
+  margin-block-end: var(--block-line-space-size);
+  margin-block-start: var(--block-line-space-size);
+  margin-inline-end: var(--inline-item-space-size);
+  margin-inline-start: var(--inline-item-space-size);
+}
+
+#container-panel #sort-containers-link {
+  align-items: center;
+  block-size: var(--block-url-label-size);
+  border: 1px solid #d8d8d8;
+  border-radius: var(--small-radius);
+  color: var(--title-text-color);
+  display: flex;
+  font-size: var(--small-text-size);
+  inline-size: var(--inline-button-size);
+  justify-content: center;
+  text-decoration: none;
+}
+
+#container-panel #sort-containers-link:hover,
+#container-panel #sort-containers-link:focus {
+  background: #f2f2f2;
+}
+
 span ~ .panel-header-text {
   padding-block-end: 0;
   padding-block-start: 0;
@@ -319,11 +474,92 @@ span ~ .panel-header-text {
   padding-inline-start: 0;
 }
 
+#current-tab {
+  align-items: center;
+  color: var(--text-normal-color);
+  display: grid;
+  font-size: var(--small-text-size);
+  grid-column-gap: var(--inline-item-space-size);
+  grid-row-gap: var(--block-line-space-size);
+  grid-template-columns: var(--icon-size) var(--icon-size) 1fr;
+  margin-block-end: var(--block-line-space-size);
+  margin-block-start: var(--block-line-separation-size);
+  margin-inline-end: var(--inline-start-size);
+  margin-inline-start: var(--inline-start-size);
+  max-inline-size: 100%;
+}
+
+#current-tab img {
+  max-block-size: var(--icon-size);
+}
+
+#current-tab > h3 {
+  color: var(--text-heading-color);
+  font-weight: normal;
+  grid-column: span 3;
+  margin-block-end: 0;
+  margin-block-start: 0;
+  margin-inline-end: 0;
+  margin-inline-start: 0;
+}
+
+#current-page {
+  display: contents;
+}
+
+#current-tab .page-title {
+  font-size: var(--font-size-heading);
+  grid-column: 2 / 4;
+}
+
+#current-tab > label {
+  display: contents;
+  font-size: var(--small-text-size);
+}
+
+#current-tab > label > input {
+  -moz-appearance: none;
+  block-size: var(--icon-size);
+  border: 1px solid #d8d8d8;
+  border-radius: var(--small-radius);
+  display: block;
+  grid-column-start: 2;
+  inline-size: var(--icon-size);
+  margin-block-end: 0;
+  margin-block-start: 0;
+  margin-inline-end: 0;
+  margin-inline-start: 0;
+}
+
+#current-tab > label > input[disabled] {
+  background-color: #efefef;
+}
+
+#current-tab > label > input:checked {
+  background-image: url("chrome://global/skin/in-content/check.svg#check-native");
+  background-position: -1px -1px;
+  background-size: var(--icon-size);
+}
+
+#current-container {
+  color: var(--identity-tab-color);
+  flex: 1;
+}
+
+#current-tab > label > .usercontext-icon {
+  background-size: 16px;
+  block-size: 16px;
+  display: block;
+  flex: 0 0 20px;
+  inline-size: 20px;
+  margin-inline-end: 3px;
+  margin-inline-start: 3px;
+}
+
 /* Rows used when iterating over panels */
 .container-panel-row {
   align-items: center;
   background-color: #fefefe !important;
-  block-size: 48px;
   border-block-end: 1px solid #f1f1f1;
   box-sizing: border-box;
   display: flex;
@@ -331,12 +567,10 @@ span ~ .panel-header-text {
 }
 
 .container-panel-row .container-name {
+  flex: 1;
   max-inline-size: 160px;
-  overflow: hidden;
   padding-inline-end: 4px;
   padding-inline-start: 4px;
-  text-overflow: ellipsis;
-  white-space: nowrap;
 }
 
 .edit-containers-panel .userContext-wrapper {
@@ -350,40 +584,46 @@ span ~ .panel-header-text {
   transition: background-color 75ms;
 }
 
-.clickable.userContext-wrapper:hover {
+.container-panel-row:hover .clickable.userContext-wrapper,
+.container-panel-row:focus .clickable.userContext-wrapper {
   background: #f2f2f2;
 }
 
 .userContext-icon-wrapper {
-  block-size: 48px;
-  flex: 0 0 48px;
+  block-size: var(--icon-button-size);
+  flex: 0 0 var(--icon-button-size);
+  margin-inline-start: var(--inline-icon-space-size);
 }
 
 /* .userContext-icon is used natively, Bug 1333811 was raised to fix */
-.userContext-icon,
 .usercontext-icon {
   background-image: var(--identity-icon);
   background-position: center center;
   background-repeat: no-repeat;
   background-size: 20px 20px;
-  block-size: 48px;
+  block-size: 100%;
   fill: var(--identity-icon-color);
   filter: url('/img/filters.svg#fill');
-  flex: 0 0 48px;
 }
 
-.clickable:hover .userContext-icon,
-.clickable:hover .usercontext-icon {
+.container-panel-row:hover .clickable .usercontext-icon,
+.container-panel-row:focus .clickable .usercontext-icon,
+.container-panel-row .clickable:focus .usercontext-icon {
   background-image: url('/img/container-newtab.svg');
-  fill: 'gray';
+  fill: #979797;
   filter: url('/img/filters.svg#fill');
 }
 
+.container-panel-row .clickable:hover .usercontext-icon,
+.container-panel-row .clickable:focus .usercontext-icon {
+  fill: #0094fb;
+}
+
 /* Panel Footer */
 .panel-footer {
   align-items: center;
   background: #efefef;
-  block-size: 54px;
+  block-size: var(--icon-button-size);
   border-block-end: 1px solid #d8d8d8;
   color: #000;
   display: flex;
@@ -392,14 +632,9 @@ span ~ .panel-header-text {
   justify-content: space-between;
 }
 
-.panel-footer .pop-button {
-  block-size: 54px;
-  flex: 0 0 54px;
-}
-
 .edit-containers-text {
   align-items: center;
-  block-size: 54px;
+  block-size: 100%;
   border-inline-end: solid 1px #d8d8d8;
   display: flex;
   flex: 1;
@@ -408,7 +643,7 @@ span ~ .panel-header-text {
 
 .edit-containers-text a {
   align-items: center;
-  block-size: 54px;
+  block-size: 100%;
   color: #0a0a0a;
   display: flex;
   flex: 1;
@@ -416,11 +651,8 @@ span ~ .panel-header-text {
 }
 
 /* Container info list */
-#container-info-name {
-  margin-inline-end: 0.5rem;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+.container-info-tab-title {
+  flex: 1;
 }
 
 #container-info-hideorshow {
@@ -465,30 +697,31 @@ span ~ .panel-header-text {
 
 .container-info-tab-row td {
   max-inline-size: 200px;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
 }
 
 .container-info-list {
-  border-block-start: 1px solid #ebebeb;
   display: flex;
   flex-direction: column;
   margin-block-start: 4px;
   padding-block-start: 4px;
 }
 
+.container-info-list tbody {
+  display: contents;
+}
+
 .clickable {
   cursor: pointer;
 }
 
-.clickable:hover {
+.clickable:hover,
+.clickable:focus {
   background-color: #ebebeb;
 }
 
 .edit-containers-exit-text {
   align-items: center;
-  background: #248aeb;
+  background: var(--primary-action-color);
   block-size: 100%;
   color: #fff;
   display: flex;
@@ -515,7 +748,7 @@ span ~ .panel-header-text {
 
 .delete-container-confirm-title {
   color: #000;
-  font-size: 16px;
+  font-size: var(--font-size-heading);
 }
 
 /* Form info */
@@ -527,36 +760,95 @@ span ~ .panel-header-text {
   padding-inline-start: 16px;
 }
 
-.column-panel-content form span {
-  align-items: center;
-  block-size: 44px;
-  display: flex;
-  flex: 0 0 25%;
-  justify-content: center;
+#edit-sites-assigned {
+  flex: 1;
 }
 
-.edit-container-panel label {
+#edit-sites-assigned h3 {
+  font-size: 14px;
+  font-weight: normal;
+  padding-block-end: 6px;
+  padding-block-start: 6px;
+  padding-inline-end: 16px;
+  padding-inline-start: 16px;
+}
+
+.assigned-sites-list > div {
+  display: flex;
+  padding-block-end: 6px;
+  padding-block-start: 6px;
+}
+
+.assigned-sites-list > div > .icon {
+  margin-inline-end: 10px;
+}
+
+.assigned-sites-list > div > .delete-assignment {
+  display: none;
+}
+
+.assigned-sites-list > div:hover > .delete-assignment {
+  display: block;
+}
+
+.assigned-sites-list > div > .hostname {
+  flex: 1;
+}
+
+.radio-choice > .radio-container {
+  align-items: center;
+  block-size: 29px;
+  display: flex;
+  flex: 0 0 calc(100% / 8);
+}
+
+.radio-choice > .radio-container > label {
+  background: none;
+  block-size: 23px;
+  border: 0;
+  filter: none;
+  inline-size: 23px;
+  margin-block-end: 0;
+  margin-block-start: 0;
+  margin-inline-end: 0;
+  margin-inline-start: 0;
+  padding-block-end: 0;
+  padding-block-start: 0;
+  padding-inline-end: 0;
+  padding-inline-start: 0;
+}
+
+.radio-choice > .radio-container > label::before {
+  background-color: unset;
   background-image: var(--identity-icon);
-  background-size: 26px 26px;
-  block-size: 34px;
+  background-position: center;
+  background-repeat: no-repeat;
+  background-size: 16px;
+  block-size: 23px;
+  border: none;
+  content: "";
+  display: block;
   fill: var(--identity-icon-color);
   filter: url('/img/filters.svg#fill');
-  flex: 0 0 34px;
+  inline-size: 23px;
   position: relative;
 }
 
-.edit-container-panel label::before {
-  opacity: 0 !important;
-}
-
-.edit-container-panel [type="radio"] {
+.radio-choice > .radio-container > [type="radio"] {
+  -moz-appearance: none;
   display: inline;
   opacity: 0;
 }
 
-.edit-container-panel [type="radio"]:checked + label {
-  outline: 2px solid grey;
-  -moz-outline-radius: 50px;
+.radio-choice > .radio-container > [type="radio"]:checked + label {
+  background: #d3d3d3;
+  border-radius: 100%;
+}
+
+/* When focusing the element add a thin blue highlight to match input fields. This gives a distinction to other selected radio items */
+.radio-choice > .radio-container > [type="radio"]:focus + label {
+  outline: 1px solid #1f9ffc;
+  -moz-outline-radius: 100%;
 }
 
 .edit-container-panel fieldset {
@@ -575,6 +867,10 @@ span ~ .panel-header-text {
   padding-inline-start: 0;
 }
 
+.edit-container-panel fieldset:last-of-type {
+  margin-block-end: 0;
+}
+
 .edit-container-panel input[type="text"] {
   block-size: 36px;
   border-radius: 3px;
@@ -589,5 +885,5 @@ span ~ .panel-header-text {
 .edit-container-panel legend {
   flex: 1 0;
   font-size: 14px !important;
-  padding-block-end: 5px;
+  padding-block-end: 6px;
 }

webextension/img/blank-tab.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 18 18">
+  <path d="M17,12v2a1,1,0,0,1-1,1H2a1,1,0,0,1-1-1V12a1,1,0,0,1,1-1H1.142c2.3,0,2.536-1.773,2.874-4,0.351-2.316.083-4,3.13-4h3.707C13.917,3,13.647,4.684,14,7c0.34,2.228.582,4,2.89,4H16A1,1,0,0,1,17,12Z" fill="white"/>
+</svg>

webextension/img/container-site.svg

@@ -0,0 +1,3 @@
+<svg width="16px" height="16px" viewBox="0 0 16 16" version="1.1" xmlns="http://www.w3.org/2000/svg">
+  <path fill="context-fill #4c4c4c" fill-opacity="context-fill-opacity" d="M12.9137931,3.0862069 L12.9137931,1.27586207 C12.9137931,0.84736528 12.5664278,0.5 12.137931,0.5 C11.7094342,0.5 11.362069,0.84736528 11.362069,1.27586207 L11.362069,1.27586207 L11.362069,3.0862069 L9.55172414,3.0862069 C9.12322735,3.0862069 8.77586207,3.43357218 8.77586207,3.86206897 C8.77586207,4.29056575 9.12322735,4.63793103 9.55172414,4.63793103 L11.362069,4.63793103 L11.362069,6.44827586 C11.362069,6.87677265 11.7094342,7.22413793 12.137931,7.22413793 L12.137931,7.22413793 C12.5664278,7.22413793 12.9137931,6.87677265 12.9137931,6.44827586 L12.9137931,6.44827586 L12.9137931,4.63793103 L14.7241379,4.63793103 C15.1526347,4.63793103 15.5,4.29056575 15.5,3.86206897 L15.5,3.86206897 C15.5,3.43357218 15.1526347,3.0862069 14.7241379,3.0862069 L14.7241379,3.0862069 L12.9137931,3.0862069 Z M0.5,9.76803178 C0.5,9.22007158 0.94118947,8.77586207 1.49216971,8.77586207 L6.23196822,8.77586207 C6.77992842,8.77586207 7.22413793,9.21705154 7.22413793,9.76803178 L7.22413793,14.5078303 C7.22413793,15.0557905 6.78294846,15.5 6.23196822,15.5 L1.49216971,15.5 C0.94420951,15.5 0.5,15.0588105 0.5,14.5078303 L0.5,9.76803178 Z M8.77586207,9.76803178 C8.77586207,9.22007158 9.21705154,8.77586207 9.76803178,8.77586207 L14.5078303,8.77586207 C15.0557905,8.77586207 15.5,9.21705154 15.5,9.76803178 L15.5,14.5078303 C15.5,15.0557905 15.0588105,15.5 14.5078303,15.5 L9.76803178,15.5 C9.22007158,15.5 8.77586207,15.0588105 8.77586207,14.5078303 L8.77586207,9.76803178 Z M0.5,1.49216971 C0.5,0.94420951 0.94118947,0.5 1.49216971,0.5 L6.23196822,0.5 C6.77992842,0.5 7.22413793,0.94118947 7.22413793,1.49216971 L7.22413793,6.23196822 C7.22413793,6.77992842 6.78294846,7.22413793 6.23196822,7.22413793 L1.49216971,7.22413793 C0.94420951,7.22413793 0.5,6.78294846 0.5,6.23196822 L0.5,1.49216971 Z"></path>
+</svg>

webextension/js/.eslintrc.js

@@ -0,0 +1,12 @@
+module.exports = {
+  "extends": [
+    "../../.eslintrc.js"
+  ],
+  "globals": {
+    "assignManager": true,
+    "badge": true,
+    "backgroundLogic": true,
+    "identityState": true,
+    "messageHandler": true
+  }
+};

webextension/js/background/assignManager.js

@@ -0,0 +1,381 @@
+const assignManager = {
+  MENU_ASSIGN_ID: "open-in-this-container",
+  MENU_REMOVE_ID: "remove-open-in-this-container",
+  MENU_SEPARATOR_ID: "separator",
+  MENU_HIDE_ID: "hide-container",
+  MENU_MOVE_ID: "move-to-new-window-container",
+
+  storageArea: {
+    area: browser.storage.local,
+    exemptedTabs: {},
+
+    getSiteStoreKey(pageUrl) {
+      const url = new window.URL(pageUrl);
+      const storagePrefix = "siteContainerMap@@_";
+      return `${storagePrefix}${url.hostname}`;
+    },
+
+    setExempted(pageUrl, tabId) {
+      const siteStoreKey = this.getSiteStoreKey(pageUrl);
+      if (!(siteStoreKey in this.exemptedTabs)) {
+        this.exemptedTabs[siteStoreKey] = [];
+      }
+      this.exemptedTabs[siteStoreKey].push(tabId);
+    },
+
+    removeExempted(pageUrl) {
+      const siteStoreKey = this.getSiteStoreKey(pageUrl);
+      this.exemptedTabs[siteStoreKey] = [];
+    },
+
+    isExempted(pageUrl, tabId) {
+      const siteStoreKey = this.getSiteStoreKey(pageUrl);
+      if (!(siteStoreKey in this.exemptedTabs)) {
+        return false;
+      }
+      return this.exemptedTabs[siteStoreKey].includes(tabId);
+    },
+
+    get(pageUrl) {
+      const siteStoreKey = this.getSiteStoreKey(pageUrl);
+      return new Promise((resolve, reject) => {
+        this.area.get([siteStoreKey]).then((storageResponse) => {
+          if (storageResponse && siteStoreKey in storageResponse) {
+            resolve(storageResponse[siteStoreKey]);
+          }
+          resolve(null);
+        }).catch((e) => {
+          reject(e);
+        });
+      });
+    },
+
+    set(pageUrl, data, exemptedTabIds) {
+      const siteStoreKey = this.getSiteStoreKey(pageUrl);
+      if (exemptedTabIds) {
+        exemptedTabIds.forEach((tabId) => {
+          this.setExempted(pageUrl, tabId);
+        });
+      }
+      return this.area.set({
+        [siteStoreKey]: data
+      });
+    },
+
+    remove(pageUrl) {
+      const siteStoreKey = this.getSiteStoreKey(pageUrl);
+      // When we remove an assignment we should clear all the exemptions
+      this.removeExempted(pageUrl);
+      return this.area.remove([siteStoreKey]);
+    },
+
+    async deleteContainer(userContextId) {
+      const sitesByContainer = await this.getByContainer(userContextId);
+      this.area.remove(Object.keys(sitesByContainer));
+    },
+
+    async getByContainer(userContextId) {
+      const sites = {};
+      const siteConfigs = await this.area.get();
+      Object.keys(siteConfigs).forEach((key) => {
+        // For some reason this is stored as string... lets check them both as that
+        if (String(siteConfigs[key].userContextId) === String(userContextId)) {
+          const site = siteConfigs[key];
+          // In hindsight we should have stored this
+          // TODO file a follow up to clean the storage onLoad
+          site.hostname = key.replace(/^siteContainerMap@@_/, "");
+          sites[key] = site;
+        }
+      });
+      return sites;
+    }
+  },
+
+  _neverAsk(m) {
+    const pageUrl = m.pageUrl;
+    if (m.neverAsk === true) {
+      // If we have existing data and for some reason it hasn't been deleted etc lets update it
+      this.storageArea.get(pageUrl).then((siteSettings) => {
+        if (siteSettings) {
+          siteSettings.neverAsk = true;
+          this.storageArea.set(pageUrl, siteSettings);
+        }
+      }).catch((e) => {
+        throw e;
+      });
+    }
+  },
+
+  // We return here so the confirm page can load the tab when exempted
+  async _exemptTab(m) {
+    const pageUrl = m.pageUrl;
+    this.storageArea.setExempted(pageUrl, m.tabId);
+    return true;
+  },
+
+  // Before a request is handled by the browser we decide if we should route through a different container
+  async onBeforeRequest(options) {
+    if (options.frameId !== 0 || options.tabId === -1) {
+      return {};
+    }
+    this.removeContextMenu();
+    const [tab, siteSettings] = await Promise.all([
+      browser.tabs.get(options.tabId),
+      this.storageArea.get(options.url)
+    ]);
+    let container;
+    try {
+      container = await browser.contextualIdentities.get(backgroundLogic.cookieStoreId(siteSettings.userContextId));
+    } catch (e) {
+      container = false;
+    }
+
+    // The container we have in the assignment map isn't present any more so lets remove it
+    //   then continue the existing load
+    if (!container) {
+      this.deleteContainer(siteSettings.userContextId);
+      return {};
+    }
+    const userContextId = this.getUserContextIdFromCookieStore(tab);
+    if (!siteSettings
+        || userContextId === siteSettings.userContextId
+        || tab.incognito
+        || this.storageArea.isExempted(options.url, tab.id)) {
+      return {};
+    }
+
+    this.reloadPageInContainer(options.url, userContextId, siteSettings.userContextId, tab.index + 1, siteSettings.neverAsk);
+    this.calculateContextMenu(tab);
+
+    /* Removal of existing tabs:
+        We aim to open the new assigned container tab / warning prompt in it's own tab:
+          - As the history won't span from one container to another it seems most sane to not try and reopen a tab on history.back()
+          - When users open a new tab themselves we want to make sure we don't end up with three tabs as per: https://github.com/mozilla/testpilot-containers/issues/421
+        If we are coming from an internal url that are used for the new tab page (NEW_TAB_PAGES), we can safely close as user is unlikely losing history
+        Detecting redirects on "new tab" opening actions is pretty hard as we don't get tab history:
+        - Redirects happen from Short URLs and tracking links that act as a gateway
+        - Extensions don't provide a way to history crawl for tabs, we could inject content scripts to do this
+            however they don't run on about:blank so this would likely be just as hacky.
+        We capture the time the tab was created and close if it was within the timeout to try to capture pages which haven't had user interaction or history.
+    */
+    if (backgroundLogic.NEW_TAB_PAGES.has(tab.url)
+        || (messageHandler.lastCreatedTab
+        && messageHandler.lastCreatedTab.id === tab.id)) {
+      browser.tabs.remove(tab.id);
+    }
+    return {
+      cancel: true,
+    };
+  },
+
+  init() {
+    browser.contextMenus.onClicked.addListener((info, tab) => {
+      this._onClickedHandler(info, tab);
+    });
+
+    // Before a request is handled by the browser we decide if we should route through a different container
+    browser.webRequest.onBeforeRequest.addListener((options) => {
+      return this.onBeforeRequest(options);
+    },{urls: ["<all_urls>"], types: ["main_frame"]}, ["blocking"]);
+  },
+
+  async _onClickedHandler(info, tab) {
+    const userContextId = this.getUserContextIdFromCookieStore(tab);
+    // Mapping ${URL(info.pageUrl).hostname} to ${userContextId}
+    let remove;
+    if (userContextId) {
+      switch (info.menuItemId) {
+      case this.MENU_ASSIGN_ID:
+      case this.MENU_REMOVE_ID:
+        if (info.menuItemId === this.MENU_ASSIGN_ID) {
+          remove = false;
+        } else {
+          remove = true;
+        }
+        await this._setOrRemoveAssignment(tab.id, info.pageUrl, userContextId, remove);
+        break;
+      case this.MENU_MOVE_ID:
+        backgroundLogic.moveTabsToWindow({
+          cookieStoreId: tab.cookieStoreId,
+          windowId: tab.windowId,
+        });
+        break;
+      case this.MENU_HIDE_ID:
+        backgroundLogic.hideTabs({
+          cookieStoreId: tab.cookieStoreId,
+          windowId: tab.windowId,
+        });
+        break;
+      }
+    }
+  },
+
+
+  deleteContainer(userContextId) {
+    this.storageArea.deleteContainer(userContextId);
+  },
+
+  getUserContextIdFromCookieStore(tab) {
+    if (!("cookieStoreId" in tab)) {
+      return false;
+    }
+    return backgroundLogic.getUserContextIdFromCookieStoreId(tab.cookieStoreId);
+  },
+
+  isTabPermittedAssign(tab) {
+    // Ensure we are not an important about url
+    // Ensure we are not in incognito mode
+    const url = new URL(tab.url);
+    if (url.protocol === "about:"
+        || url.protocol === "moz-extension:"
+        || tab.incognito) {
+      return false;
+    }
+    return true;
+  },
+
+  async _setOrRemoveAssignment(tabId, pageUrl, userContextId, remove) {
+    let actionName;
+
+    // https://github.com/mozilla/testpilot-containers/issues/626
+    // Context menu has stored context IDs as strings, so we need to coerce
+    // the value to a string for accurate checking
+    userContextId = String(userContextId);
+
+    if (!remove) {
+      const tabs = await browser.tabs.query({});
+      const assignmentStoreKey = this.storageArea.getSiteStoreKey(pageUrl);
+      const exemptedTabIds = tabs.filter((tab) => {
+        const tabStoreKey = this.storageArea.getSiteStoreKey(tab.url);
+        /* Auto exempt all tabs that exist for this hostname that are not in the same container */
+        if (tabStoreKey === assignmentStoreKey &&
+            this.getUserContextIdFromCookieStore(tab) !== userContextId) {
+          return true;
+        }
+        return false;
+      }).map((tab) => {
+        return tab.id;
+      });
+
+      await this.storageArea.set(pageUrl, {
+        userContextId,
+        neverAsk: false
+      }, exemptedTabIds);
+      actionName = "added";
+    } else {
+      await this.storageArea.remove(pageUrl);
+      actionName = "removed";
+    }
+    browser.tabs.sendMessage(tabId, {
+      text: `Successfully ${actionName} site to always open in this container`
+    });
+    const tab = await browser.tabs.get(tabId);
+    this.calculateContextMenu(tab);
+  },
+
+  async _getAssignment(tab) {
+    const cookieStore = this.getUserContextIdFromCookieStore(tab);
+    // Ensure we have a cookieStore to assign to
+    if (cookieStore
+        && this.isTabPermittedAssign(tab)) {
+      return await this.storageArea.get(tab.url);
+    }
+    return false;
+  },
+
+  _getByContainer(userContextId) {
+    return this.storageArea.getByContainer(userContextId);
+  },
+
+  removeContextMenu() {
+    // There is a focus issue in this menu where if you change window with a context menu click
+    // you get the wrong menu display because of async
+    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1215376#c16
+    // We also can't change for always private mode
+    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1352102
+    browser.contextMenus.remove(this.MENU_ASSIGN_ID);
+    browser.contextMenus.remove(this.MENU_REMOVE_ID);
+    browser.contextMenus.remove(this.MENU_SEPARATOR_ID);
+    browser.contextMenus.remove(this.MENU_HIDE_ID);
+    browser.contextMenus.remove(this.MENU_MOVE_ID);
+  },
+
+  async calculateContextMenu(tab) {
+    this.removeContextMenu();
+    const siteSettings = await this._getAssignment(tab);
+    // Return early and not add an item if we have false
+    // False represents assignment is not permitted
+    if (siteSettings === false) {
+      return false;
+    }
+    let checked = false;
+    let menuId = this.MENU_ASSIGN_ID;
+    const tabUserContextId = this.getUserContextIdFromCookieStore(tab);
+    if (siteSettings &&
+        Number(siteSettings.userContextId) === Number(tabUserContextId)) {
+      checked = true;
+      menuId = this.MENU_REMOVE_ID;
+    }
+    browser.contextMenus.create({
+      id: menuId,
+      title: "Always Open in This Container",
+      checked,
+      type: "checkbox",
+      contexts: ["all"],
+    });
+
+    browser.contextMenus.create({
+      id: this.MENU_SEPARATOR_ID,
+      type: "separator",
+      contexts: ["all"],
+    });
+
+    browser.contextMenus.create({
+      id: this.MENU_HIDE_ID,
+      title: "Hide This Container",
+      contexts: ["all"],
+    });
+
+    browser.contextMenus.create({
+      id: this.MENU_MOVE_ID,
+      title: "Move Tabs to a New Window",
+      contexts: ["all"],
+    });
+  },
+
+  encodeURLProperty(url) {
+    return encodeURIComponent(url).replace(/[!'()*]/g, (c) => {
+      const charCode = c.charCodeAt(0).toString(16);
+      return `%${charCode}`;
+    });
+  },
+
+  reloadPageInContainer(url, currentUserContextId, userContextId, index, neverAsk = false) {
+    const cookieStoreId = backgroundLogic.cookieStoreId(userContextId);
+    const loadPage = browser.extension.getURL("confirm-page.html");
+    // False represents assignment is not permitted
+    // If the user has explicitly checked "Never Ask Again" on the warning page we will send them straight there
+    if (neverAsk) {
+      browser.tabs.create({url, cookieStoreId, index});
+    } else {
+      let confirmUrl = `${loadPage}?url=${this.encodeURLProperty(url)}&cookieStoreId=${cookieStoreId}`;
+      let currentCookieStoreId;
+      if (currentUserContextId) {
+        currentCookieStoreId = backgroundLogic.cookieStoreId(currentUserContextId);
+        confirmUrl += `&currentCookieStoreId=${currentCookieStoreId}`;
+      }
+      browser.tabs.create({
+        url: confirmUrl,
+        cookieStoreId: currentCookieStoreId,
+        index
+      }).then(() => {
+        // We don't want to sync this URL ever nor clutter the users history
+        browser.history.deleteUrl({url: confirmUrl});
+      }).catch((e) => {
+        throw e;
+      });
+    }
+  }
+};
+
+assignManager.init();

webextension/js/background/backgroundLogic.js

@@ -0,0 +1,306 @@
+const DEFAULT_TAB = "about:newtab";
+const backgroundLogic = {
+  NEW_TAB_PAGES: new Set([
+    "about:startpage",
+    "about:newtab",
+    "about:home",
+    "about:blank"
+  ]),
+
+  async getExtensionInfo() {
+    const manifestPath = browser.extension.getURL("manifest.json");
+    const response = await fetch(manifestPath);
+    const extensionInfo = await response.json();
+    return extensionInfo;
+  },
+
+  getUserContextIdFromCookieStoreId(cookieStoreId) {
+    if (!cookieStoreId) {
+      return false;
+    }
+    const container = cookieStoreId.replace("firefox-container-", "");
+    if (container !== cookieStoreId) {
+      return container;
+    }
+    return false;
+  },
+
+  async deleteContainer(userContextId, removed = false) {
+    await this._closeTabs(userContextId);
+    if (!removed) {
+      await browser.contextualIdentities.remove(this.cookieStoreId(userContextId));
+    }
+    assignManager.deleteContainer(userContextId);
+    return {done: true, userContextId};
+  },
+
+  async createOrUpdateContainer(options) {
+    let donePromise;
+    if (options.userContextId !== "new") {
+      donePromise = browser.contextualIdentities.update(
+        this.cookieStoreId(options.userContextId),
+        options.params
+      );
+    } else {
+      donePromise = browser.contextualIdentities.create(options.params);
+    }
+    await donePromise;
+    browser.runtime.sendMessage({
+      method: "refreshNeeded"
+    });
+  },
+
+  async openNewTab(options) {
+    let url = options.url || undefined;
+    const userContextId = ("userContextId" in options) ? options.userContextId : 0;
+    const active = ("nofocus" in options) ? options.nofocus : true;
+
+    const cookieStoreId = backgroundLogic.cookieStoreId(userContextId);
+    // Autofocus url bar will happen in 54: https://bugzilla.mozilla.org/show_bug.cgi?id=1295072
+
+    // We can't open new tab pages, so open a blank tab. Used in tab un-hide
+    if (this.NEW_TAB_PAGES.has(url)) {
+      url = undefined;
+    }
+
+    if (!this.isPermissibleURL(url)) {
+      return;
+    }
+
+    return browser.tabs.create({
+      url,
+      active,
+      pinned: options.pinned || false,
+      cookieStoreId
+    });
+  },
+
+  isPermissibleURL(url) {
+    const protocol = new URL(url).protocol;
+    // We can't open these we just have to throw them away
+    if (protocol === "about:"
+        || protocol === "chrome:"
+        || protocol === "moz-extension:") {
+      return false;
+    }
+    return true;
+  },
+
+  checkArgs(requiredArguments, options, methodName) {
+    requiredArguments.forEach((argument) => {
+      if (!(argument in options)) {
+        return new Error(`${methodName} must be called with ${argument} argument.`);
+      }
+    });
+  },
+
+  async getTabs(options) {
+    const requiredArguments = ["cookieStoreId", "windowId"];
+    this.checkArgs(requiredArguments, options, "getTabs");
+    const { cookieStoreId, windowId } = options;
+
+    const list = [];
+    const tabs = await browser.tabs.query({
+      cookieStoreId,
+      windowId
+    });
+    tabs.forEach((tab) => {
+      list.push(identityState._createTabObject(tab));
+    });
+
+    const containerState = await identityState.storageArea.get(cookieStoreId);
+    return list.concat(containerState.hiddenTabs);
+  },
+
+  async moveTabsToWindow(options) {
+    const requiredArguments = ["cookieStoreId", "windowId"];
+    this.checkArgs(requiredArguments, options, "moveTabsToWindow");
+    const { cookieStoreId, windowId } = options;
+
+    const list = await browser.tabs.query({
+      cookieStoreId,
+      windowId
+    });
+
+    const containerState = await identityState.storageArea.get(cookieStoreId);
+    // Nothing to do
+    if (list.length === 0 &&
+        containerState.hiddenTabs.length === 0) {
+      return;
+    }
+    let newWindowObj;
+    let hiddenDefaultTabToClose;
+    if (list.length) {
+      newWindowObj = await browser.windows.create({
+        tabId: list.shift().id
+      });
+      browser.tabs.move(list.map((tab) => tab.id), {
+        windowId: newWindowObj.id,
+        index: -1
+      });
+    } else {
+      //As we get a blank tab here we will need to await the tabs creation
+      newWindowObj = await browser.windows.create({
+      });
+      hiddenDefaultTabToClose = true;
+    }
+
+    const showHiddenPromises = [];
+
+    // Let's show the hidden tabs.
+    for (let object of containerState.hiddenTabs) { // eslint-disable-line prefer-const
+      showHiddenPromises.push(browser.tabs.create({
+        url: object.url || DEFAULT_TAB,
+        windowId: newWindowObj.id,
+        cookieStoreId
+      }));
+    }
+
+    if (hiddenDefaultTabToClose) {
+      // Lets wait for hidden tabs to show before closing the others
+      await showHiddenPromises;
+    }
+
+    containerState.hiddenTabs = [];
+
+    // Let's close all the normal tab in the new window. In theory it
+    // should be only the first tab, but maybe there are addons doing
+    // crazy stuff.
+    const tabs = await browser.tabs.query({windowId: newWindowObj.id});
+    for (let tab of tabs) { // eslint-disable-line prefer-const
+      if (tab.cookieStoreId !== cookieStoreId) {
+        browser.tabs.remove(tab.id);
+      }
+    }
+    return await identityState.storageArea.set(cookieStoreId, containerState);
+  },
+
+  async _closeTabs(userContextId, windowId = false) {
+    const cookieStoreId = this.cookieStoreId(userContextId);
+    let tabs;
+    /* if we have no windowId we are going to close all this container (used for deleting) */
+    if (windowId !== false) {
+      tabs = await browser.tabs.query({
+        cookieStoreId,
+        windowId
+      });
+    } else {
+      tabs = await browser.tabs.query({
+        cookieStoreId
+      });
+    }
+    const tabIds = tabs.map((tab) => tab.id);
+    return browser.tabs.remove(tabIds);
+  },
+
+  async queryIdentitiesState(windowId) {
+    const identities = await browser.contextualIdentities.query({});
+    const identitiesOutput = {};
+    const identitiesPromise = identities.map(async function (identity) {
+      const { cookieStoreId } = identity;
+      const containerState = await identityState.storageArea.get(cookieStoreId);
+      const openTabs = await browser.tabs.query({
+        cookieStoreId,
+        windowId
+      });
+      identitiesOutput[cookieStoreId] = {
+        hasHiddenTabs: !!containerState.hiddenTabs.length,
+        hasOpenTabs: !!openTabs.length
+      };
+      return;
+    });
+    await Promise.all(identitiesPromise);
+    return identitiesOutput;
+  },
+
+  async sortTabs() {
+    const windows = await browser.windows.getAll();
+    for (let windowObj of windows) { // eslint-disable-line prefer-const
+      // First the pinned tabs, then the normal ones.
+      await this._sortTabsInternal(windowObj, true);
+      await this._sortTabsInternal(windowObj, false);
+    }
+  },
+
+  async _sortTabsInternal(windowObj, pinnedTabs) {
+    const tabs = await browser.tabs.query({windowId: windowObj.id});
+    let pos = 0;
+
+    // Let's collect UCIs/tabs for this window.
+    const map = new Map;
+    for (const tab of tabs) {
+      if (pinnedTabs && !tab.pinned) {
+        // We don't have, or we already handled all the pinned tabs.
+        break;
+      }
+
+      if (!pinnedTabs && tab.pinned) {
+        // pinned tabs must be consider as taken positions.
+        ++pos;
+        continue;
+      }
+
+      const userContextId = backgroundLogic.getUserContextIdFromCookieStoreId(tab.cookieStoreId);
+      if (!map.has(userContextId)) {
+        map.set(userContextId, []);
+      }
+      map.get(userContextId).push(tab);
+    }
+
+    // Let's sort the map.
+    const sortMap = new Map([...map.entries()].sort((a, b) => a[0] > b[0]));
+
+    // Let's move tabs.
+    sortMap.forEach(tabs => {
+      for (const tab of tabs) {
+        ++pos;
+        browser.tabs.move(tab.id, {
+          windowId: windowObj.id,
+          index: pos
+        });
+      }
+    });
+  },
+
+  async hideTabs(options) {
+    const requiredArguments = ["cookieStoreId", "windowId"];
+    this.checkArgs(requiredArguments, options, "hideTabs");
+    const { cookieStoreId, windowId } = options;
+
+    const userContextId = backgroundLogic.getUserContextIdFromCookieStoreId(cookieStoreId);
+
+    const containerState = await identityState.storeHidden(cookieStoreId, windowId);
+    await this._closeTabs(userContextId, windowId);
+    return containerState;
+  },
+
+  async showTabs(options) {
+    if (!("cookieStoreId" in options)) {
+      return Promise.reject("showTabs must be called with cookieStoreId argument.");
+    }
+
+    const userContextId = backgroundLogic.getUserContextIdFromCookieStoreId(options.cookieStoreId);
+    const promises = [];
+
+    const containerState = await identityState.storageArea.get(options.cookieStoreId);
+
+    for (let object of containerState.hiddenTabs) { // eslint-disable-line prefer-const
+      promises.push(this.openNewTab({
+        userContextId: userContextId,
+        url: object.url,
+        nofocus: options.nofocus || false,
+        pinned: object.pinned,
+      }));
+    }
+
+    containerState.hiddenTabs = [];
+
+    await Promise.all(promises);
+    return await identityState.storageArea.set(options.cookieStoreId, containerState);
+  },
+
+  cookieStoreId(userContextId) {
+    return `firefox-container-${userContextId}`;
+  }
+};
+

webextension/js/background/badge.js

@@ -0,0 +1,25 @@
+const MAJOR_VERSIONS = ["2.3.0", "2.4.0"];
+const badge = {
+  async init() {
+    const currentWindow = await browser.windows.getCurrent();
+    this.displayBrowserActionBadge(currentWindow.incognito);
+  },
+
+  disableAddon(tabId) {
+    browser.browserAction.disable(tabId);
+    browser.browserAction.setTitle({ tabId, title: "Containers disabled in Private Browsing Mode" });
+  },
+
+  async displayBrowserActionBadge() {
+    const extensionInfo = await backgroundLogic.getExtensionInfo();
+    const storage = await browser.storage.local.get({browserActionBadgesClicked: []});
+
+    if (MAJOR_VERSIONS.indexOf(extensionInfo.version) > -1 &&
+        storage.browserActionBadgesClicked.indexOf(extensionInfo.version) < 0) {
+      browser.browserAction.setBadgeBackgroundColor({color: "rgba(0,217,0,255)"});
+      browser.browserAction.setBadgeText({text: "NEW"});
+    }
+  }
+};
+
+badge.init();

webextension/js/background/identityState.js

@@ -0,0 +1,62 @@
+const identityState = {
+  storageArea: {
+    area: browser.storage.local,
+
+    getContainerStoreKey(cookieStoreId) {
+      const storagePrefix = "identitiesState@@_";
+      return `${storagePrefix}${cookieStoreId}`;
+    },
+
+    async get(cookieStoreId) {
+      const storeKey = this.getContainerStoreKey(cookieStoreId);
+      const storageResponse = await this.area.get([storeKey]);
+      if (storageResponse && storeKey in storageResponse) {
+        return storageResponse[storeKey];
+      }
+      const defaultContainerState = identityState._createIdentityState();
+      await this.set(cookieStoreId, defaultContainerState);
+
+      return defaultContainerState;
+    },
+
+    set(cookieStoreId, data) {
+      const storeKey = this.getContainerStoreKey(cookieStoreId);
+      return this.area.set({
+        [storeKey]: data
+      });
+    },
+
+    remove(cookieStoreId) {
+      const storeKey = this.getContainerStoreKey(cookieStoreId);
+      return this.area.remove([storeKey]);
+    }
+  },
+
+  _createTabObject(tab) {
+    return Object.assign({}, tab);
+  },
+
+  async storeHidden(cookieStoreId, windowId) {
+    const containerState = await this.storageArea.get(cookieStoreId);
+    const tabsByContainer = await browser.tabs.query({cookieStoreId, windowId});
+    tabsByContainer.forEach((tab) => {
+      const tabObject = this._createTabObject(tab);
+      if (!backgroundLogic.isPermissibleURL(tab.url)) {
+        return;
+      }
+      // This tab is going to be closed. Let's mark this tabObject as
+      // non-active.
+      tabObject.active = false;
+      tabObject.hiddenState = true;
+      containerState.hiddenTabs.push(tabObject);
+    });
+
+    return this.storageArea.set(cookieStoreId, containerState);
+  },
+
+  _createIdentityState() {
+    return {
+      hiddenTabs: []
+    };
+  },
+};

webextension/js/background/index.html

@@ -0,0 +1,22 @@
+<html>
+  <head>
+    <meta charset="utf-8">
+  </head>
+  <body>
+ <!--
+    This didn't work for debugging in the manifest.
+    "scripts": [
+      "js/background/backgroundLogic.js",
+      "js/background/assignManager.js",
+      "js/background/badge.js",
+      "js/background/identityState.js",
+      "js/background/messageHandler.js",
+    ]
+-->
+    <script type="text/javascript" src="backgroundLogic.js"></script>
+    <script type="text/javascript" src="assignManager.js"></script>
+    <script type="text/javascript" src="badge.js"></script>
+    <script type="text/javascript" src="identityState.js"></script>
+    <script type="text/javascript" src="messageHandler.js"></script>
+  </body>
+</html>

webextension/js/background/messageHandler.js

@@ -0,0 +1,152 @@
+const messageHandler = {
+  // After the timer completes we assume it's a tab the user meant to keep open
+  // We use this to catch redirected tabs that have just opened
+  // If this were in platform we would change how the tab opens based on "new tab" link navigations such as ctrl+click
+  LAST_CREATED_TAB_TIMER: 2000,
+  unhideQueue: [],
+
+  init() {
+    // Handles messages from webextension code
+    browser.runtime.onMessage.addListener((m) => {
+      let response;
+
+      switch (m.method) {
+      case "deleteContainer":
+        response = backgroundLogic.deleteContainer(m.message.userContextId);
+        break;
+      case "createOrUpdateContainer":
+        response = backgroundLogic.createOrUpdateContainer(m.message);
+        break;
+      case "neverAsk":
+        assignManager._neverAsk(m);
+        break;
+      case "getAssignment":
+        response = browser.tabs.get(m.tabId).then((tab) => {
+          return assignManager._getAssignment(tab);
+        });
+        break;
+      case "getAssignmentObjectByContainer":
+        response = assignManager._getByContainer(m.message.userContextId);
+        break;
+      case "setOrRemoveAssignment":
+        // m.tabId is used for where to place the in content message
+        // m.url is the assignment to be removed/added
+        response = browser.tabs.get(m.tabId).then((tab) => {
+          return assignManager._setOrRemoveAssignment(tab.id, m.url, m.userContextId, m.value);
+        });
+        break;
+      case "sortTabs":
+        backgroundLogic.sortTabs();
+        break;
+      case "showTabs":
+        this.unhideContainer(m.cookieStoreId);
+        break;
+      case "hideTabs":
+        backgroundLogic.hideTabs({
+          cookieStoreId: m.cookieStoreId,
+          windowId: m.windowId
+        });
+        break;
+      case "checkIncompatibleAddons":
+        // TODO
+        break;
+      case "moveTabsToWindow":
+        response = backgroundLogic.moveTabsToWindow({
+          cookieStoreId: m.cookieStoreId,
+          windowId: m.windowId
+        });
+        break;
+      case "getTabs":
+        response = backgroundLogic.getTabs({
+          cookieStoreId: m.cookieStoreId,
+          windowId: m.windowId
+        });
+        break;
+      case "queryIdentitiesState":
+        response = backgroundLogic.queryIdentitiesState(m.message.windowId);
+        break;
+      case "exemptContainerAssignment":
+        response = assignManager._exemptTab(m);
+        break;
+      }
+      return response;
+    });
+
+    if (browser.contextualIdentities.onRemoved) {
+      browser.contextualIdentities.onRemoved.addListener(({contextualIdentity}) => {
+        const userContextId = backgroundLogic.getUserContextIdFromCookieStoreId(contextualIdentity.cookieStoreId);
+        backgroundLogic.deleteContainer(userContextId, true);
+      });
+    }
+
+    browser.tabs.onActivated.addListener((info) => {
+      assignManager.removeContextMenu();
+      browser.tabs.get(info.tabId).then((tab) => {
+        assignManager.calculateContextMenu(tab);
+      }).catch((e) => {
+        throw e;
+      });
+    });
+
+    browser.windows.onFocusChanged.addListener((windowId) => {
+      this.onFocusChangedCallback(windowId);
+    });
+
+    browser.webRequest.onCompleted.addListener((details) => {
+      if (details.frameId !== 0 || details.tabId === -1) {
+        return {};
+      }
+      assignManager.removeContextMenu();
+
+      browser.tabs.get(details.tabId).then((tab) => {
+        assignManager.calculateContextMenu(tab);
+      }).catch((e) => {
+        throw e;
+      });
+    }, {urls: ["<all_urls>"], types: ["main_frame"]});
+
+    browser.tabs.onCreated.addListener((tab) => {
+      if (tab.incognito) {
+        badge.disableAddon(tab.id);
+      }
+      // lets remember the last tab created so we can close it if it looks like a redirect
+      this.lastCreatedTab = tab;
+      if (tab.cookieStoreId) {
+        this.unhideContainer(tab.cookieStoreId);
+      }
+      setTimeout(() => {
+        this.lastCreatedTab = null;
+      }, this.LAST_CREATED_TAB_TIMER);
+    });
+  },
+
+  async unhideContainer(cookieStoreId) {
+    if (!this.unhideQueue.includes(cookieStoreId)) {
+      this.unhideQueue.push(cookieStoreId);
+      // Unhide all hidden tabs
+      await backgroundLogic.showTabs({
+        cookieStoreId
+      });
+      this.unhideQueue.splice(this.unhideQueue.indexOf(cookieStoreId), 1);
+    }
+  },
+
+  async onFocusChangedCallback(windowId) {
+    assignManager.removeContextMenu();
+    // browserAction loses background color in new windows ...
+    // https://bugzil.la/1314674
+    // https://github.com/mozilla/testpilot-containers/issues/608
+    // ... so re-call displayBrowserActionBadge on window changes
+    badge.displayBrowserActionBadge();
+    browser.tabs.query({active: true, windowId}).then((tabs) => {
+      if (tabs && tabs[0]) {
+        assignManager.calculateContextMenu(tabs[0]);
+      }
+    }).catch((e) => {
+      throw e;
+    });
+  }
+};
+
+// Lets do this last as theme manager did a check before connecting before
+messageHandler.init();

webextension/js/confirm-page.js

@@ -1,30 +1,84 @@
-const redirectUrl = new URL(window.location).searchParams.get("url");
-document.getElementById("redirect-url").textContent = redirectUrl;
-const redirectSite = new URL(redirectUrl).hostname;
-document.getElementById("redirect-site").textContent = redirectSite;
+async function load() {
+  const searchParams = new URL(window.location).searchParams;
+  const redirectUrl = decodeURIComponent(searchParams.get("url"));
+  const cookieStoreId = searchParams.get("cookieStoreId");
+  const currentCookieStoreId = searchParams.get("currentCookieStoreId");
+  const redirectUrlElement = document.getElementById("redirect-url");
+  redirectUrlElement.textContent = redirectUrl;
+  appendFavicon(redirectUrl, redirectUrlElement);
 
-document.getElementById("redirect-form").addEventListener("submit", (e) => {
-  e.preventDefault();
+  const container = await browser.contextualIdentities.get(cookieStoreId);
+  [...document.querySelectorAll(".container-name")].forEach((containerNameElement) => {
+    containerNameElement.textContent = container.name;
+  });
+
+  // If default container, button will default to normal HTML content
+  if (currentCookieStoreId) {
+    const currentContainer = await browser.contextualIdentities.get(currentCookieStoreId);
+    document.getElementById("current-container-name").textContent = currentContainer.name;
+  }
+
+  document.getElementById("redirect-form").addEventListener("submit", (e) => {
+    e.preventDefault();
+    const buttonTarget = e.explicitOriginalTarget;
+    switch (buttonTarget.id) {
+    case "confirm":
+      confirmSubmit(redirectUrl, cookieStoreId);
+      break;
+    case "deny":
+      denySubmit(redirectUrl);
+      break;
+    }
+  });
+}
+
+function appendFavicon(pageUrl, redirectUrlElement) {
+  const origin = new URL(pageUrl).origin;
+  const favIconElement = Utils.createFavIconElement(`${origin}/favicon.ico`);
+
+  redirectUrlElement.prepend(favIconElement);
+}
+
+function confirmSubmit(redirectUrl, cookieStoreId) {
   const neverAsk = document.getElementById("never-ask").checked;
   // Sending neverAsk message to background to store for next time we see this process
   if (neverAsk) {
     browser.runtime.sendMessage({
+      method: "neverAsk",
       neverAsk: true,
       pageUrl: redirectUrl
-    }).then(() => {
-      redirect();
-    }).catch(() => {
-      // Can't really do much here user will have to click it again
     });
   }
-  browser.runtime.sendMessage({
-    method: "sendTelemetryPayload",
-    event: "click-to-reload-page-in-container",
-  });
-  redirect();
-});
+  openInContainer(redirectUrl, cookieStoreId);
+}
 
-function redirect() {
-  const redirectUrl = document.getElementById("redirect-url").textContent;
+function getCurrentTab() {
+  return browser.tabs.query({
+    active: true,
+    windowId: browser.windows.WINDOW_ID_CURRENT
+  });
+}
+
+async function denySubmit(redirectUrl) {
+  const tab = await getCurrentTab();
+  await browser.runtime.sendMessage({
+    method: "exemptContainerAssignment",
+    tabId: tab[0].id,
+    pageUrl: redirectUrl
+  });
   document.location.replace(redirectUrl);
 }
+
+load();
+
+async function openInContainer(redirectUrl, cookieStoreId) {
+  const tab = await getCurrentTab();
+  await browser.tabs.create({
+    index: tab[0].index + 1,
+    cookieStoreId,
+    url: redirectUrl
+  });
+  if (tab.length > 0) {
+    browser.tabs.remove(tab[0].id);
+  }
+}

webextension/js/content-script.js

@@ -0,0 +1,46 @@
+async function delayAnimation(delay = 350) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+}
+
+async function doAnimation(element, property, value) {
+  return new Promise((resolve) => {
+    const handler = () => {
+      resolve();
+      element.removeEventListener("transitionend", handler);
+    };
+    element.addEventListener("transitionend", handler);
+    window.requestAnimationFrame(() => {
+      element.style[property] = value;
+    });
+  });
+}
+
+async function addMessage(message) {
+  const divElement = document.createElement("div");
+  divElement.classList.add("container-notification");
+  // Ideally we would use https://bugzilla.mozilla.org/show_bug.cgi?id=1340930 when this is available
+  divElement.innerText = message.text;
+
+  const imageElement = document.createElement("img");
+  const imagePath = browser.extension.getURL("/img/container-site-d-24.png");
+  const response = await fetch(imagePath);
+  const blob = await response.blob();
+  const objectUrl = URL.createObjectURL(blob);
+  imageElement.src = objectUrl;
+  divElement.prepend(imageElement);
+
+  document.body.appendChild(divElement);
+
+  await delayAnimation(100);
+  await doAnimation(divElement, "transform", "translateY(0)");
+  await delayAnimation(3000);
+  await doAnimation(divElement, "transform", "translateY(-100%)");
+
+  divElement.remove();
+}
+
+browser.runtime.onMessage.addListener((message) => {
+  addMessage(message);
+});

webextension/js/popup.js

@@ -7,11 +7,16 @@ const CONTAINER_UNHIDE_SRC = "/img/container-unhide.svg";
 
 const DEFAULT_COLOR = "blue";
 const DEFAULT_ICON = "circle";
+const NEW_CONTAINER_ID = "new";
+
+const ONBOARDING_STORAGE_KEY = "onboarding-stage";
 
 // List of panels
 const P_ONBOARDING_1     = "onboarding1";
 const P_ONBOARDING_2     = "onboarding2";
 const P_ONBOARDING_3     = "onboarding3";
+const P_ONBOARDING_4     = "onboarding4";
+const P_ONBOARDING_5     = "onboarding5";
 const P_CONTAINERS_LIST  = "containersList";
 const P_CONTAINERS_EDIT  = "containersEdit";
 const P_CONTAINER_INFO   = "containerInfo";
@@ -54,6 +59,13 @@ function escaped(strings, ...values) {
   return result.join("");
 }
 
+async function getExtensionInfo() {
+  const manifestPath = browser.extension.getURL("manifest.json");
+  const response = await fetch(manifestPath);
+  const extensionInfo = await response.json();
+  return extensionInfo;
+}
+
 // This object controls all the panels, identities and many other things.
 const Logic = {
   _identities: [],
@@ -61,40 +73,143 @@ const Logic = {
   _currentPanel: null,
   _previousPanel: null,
   _panels: {},
+  _onboardingVariation: null,
+
+  async init() {
+    // Remove browserAction "upgraded" badge when opening panel
+    this.clearBrowserActionBadge();
 
-  init() {
     // Retrieve the list of identities.
-    this.refreshIdentities()
+    const identitiesPromise = this.refreshIdentities();
+
+    try {
+      await identitiesPromise;
+    } catch(e) {
+      throw new Error("Failed to retrieve the identities or variation. We cannot continue. ", e.message);
+    }
 
     // Routing to the correct panel.
-    .then(() => {
-      // If localStorage is disabled, we don't show the onboarding.
-      if (!localStorage || localStorage.getItem("onboarded3")) {
-        this.showPanel(P_CONTAINERS_LIST);
-      } else if (localStorage.getItem("onboarded2")) {
-        this.showPanel(P_ONBOARDING_3);
-      } else if (localStorage.getItem("onboarded1")) {
-        this.showPanel(P_ONBOARDING_2);
-      } else {
-        this.showPanel(P_ONBOARDING_1);
+    // If localStorage is disabled, we don't show the onboarding.
+    const data = await browser.storage.local.get([ONBOARDING_STORAGE_KEY]);
+    let onboarded = data[ONBOARDING_STORAGE_KEY];
+    if (!onboarded) {
+      onboarded = 0;
+      this.setOnboardingStage(onboarded);
+    }
+
+    switch (onboarded) {
+    case 5:
+      this.showPanel(P_CONTAINERS_LIST);
+      break;
+    case 4:
+      this.showPanel(P_ONBOARDING_5);
+      break;
+    case 3:
+      this.showPanel(P_ONBOARDING_4);
+      break;
+    case 2:
+      this.showPanel(P_ONBOARDING_3);
+      break;
+    case 1:
+      this.showPanel(P_ONBOARDING_2);
+      break;
+    case 0:
+    default:
+      this.showPanel(P_ONBOARDING_1);
+      break;
+    }
+
+  },
+
+  setOnboardingStage(stage) {
+    return browser.storage.local.set({
+      [ONBOARDING_STORAGE_KEY]: stage
+    });
+  },
+
+  async clearBrowserActionBadge() {
+    const extensionInfo = await getExtensionInfo();
+    const storage = await browser.storage.local.get({browserActionBadgesClicked: []});
+    browser.browserAction.setBadgeBackgroundColor({color: ""});
+    browser.browserAction.setBadgeText({text: ""});
+    storage.browserActionBadgesClicked.push(extensionInfo.version);
+    // use set and spread to create a unique array
+    const browserActionBadgesClicked = [...new Set(storage.browserActionBadgesClicked)];
+    browser.storage.local.set({
+      browserActionBadgesClicked
+    });
+  },
+
+  async identity(cookieStoreId) {
+    const defaultContainer = {
+      name: "Default",
+      cookieStoreId,
+      icon: "default-tab",
+      color: "default-tab"
+    };
+    // Handle old style rejection with null and also Promise.reject new style
+    try {
+      return await browser.contextualIdentities.get(cookieStoreId) || defaultContainer;
+    } catch(e) {
+      return defaultContainer;
+    }
+  },
+
+  addEnterHandler(element, handler) {
+    element.addEventListener("click", (e) => {
+      handler(e);
+    });
+    element.addEventListener("keydown", (e) => {
+      if (e.keyCode === 13) {
+        e.preventDefault();
+        handler(e);
       }
-    })
-
-    .catch(() => {
-      throw new Error("Failed to retrieve the identities. We cannot continue.");
     });
   },
 
-  refreshIdentities() {
-    return browser.runtime.sendMessage({
-      method: "queryIdentities"
-    })
-    .then(identities => {
-      this._identities = identities;
+  userContextId(cookieStoreId = "") {
+    const userContextId = cookieStoreId.replace("firefox-container-", "");
+    return (userContextId !== cookieStoreId) ? Number(userContextId) : false;
+  },
+
+  async currentTab() {
+    const activeTabs = await browser.tabs.query({active: true, windowId: browser.windows.WINDOW_ID_CURRENT});
+    if (activeTabs.length > 0) {
+      return activeTabs[0];
+    }
+    return false;
+  },
+
+  async refreshIdentities() {
+    const [identities, state] = await Promise.all([
+      browser.contextualIdentities.query({}),
+      browser.runtime.sendMessage({
+        method: "queryIdentitiesState",
+        message: {
+          windowId: browser.windows.WINDOW_ID_CURRENT
+        }
+      })
+    ]);
+    this._identities = identities.map((identity) => {
+      const stateObject = state[identity.cookieStoreId];
+      if (stateObject) {
+        identity.hasOpenTabs = stateObject.hasOpenTabs;
+        identity.hasHiddenTabs = stateObject.hasHiddenTabs;
+      }
+      return identity;
     });
   },
 
-  showPanel(panel, currentIdentity = null) {
+  getPanelSelector(panel) {
+    if (this._onboardingVariation === "securityOnboarding" &&
+        panel.hasOwnProperty("securityPanelSelector")) {
+      return panel.securityPanelSelector;
+    } else {
+      return panel.panelSelector;
+    }
+  },
+
+  async showPanel(panel, currentIdentity = null) {
     // Invalid panel... ?!?
     if (!(panel in this._panels)) {
       throw new Error("Something really bad happened. Unknown panel: " + panel);
@@ -106,15 +221,18 @@ const Logic = {
     this._currentIdentity = currentIdentity;
 
     // Initialize the panel before showing it.
-    this._panels[panel].prepare().then(() => {
-      for (let panelElement of document.querySelectorAll(".panel")) { // eslint-disable-line prefer-const
+    await this._panels[panel].prepare();
+    Object.keys(this._panels).forEach((panelKey) => {
+      const panelItem = this._panels[panelKey];
+      const panelElement = document.querySelector(this.getPanelSelector(panelItem));
+      if (!panelElement.classList.contains("hide")) {
         panelElement.classList.add("hide");
+        if ("unregister" in panelItem) {
+          panelItem.unregister();
+        }
       }
-      document.querySelector(this._panels[panel].panelSelector).classList.remove("hide");
-    })
-    .catch(() => {
-      throw new Error("Failed to show panel " + panel);
     });
+    document.querySelector(this.getPanelSelector(this._panels[panel])).classList.remove("hide");
   },
 
   showPreviousPanel() {
@@ -141,6 +259,51 @@ const Logic = {
     return this._currentIdentity;
   },
 
+  currentUserContextId() {
+    const identity = Logic.currentIdentity();
+    return Logic.userContextId(identity.cookieStoreId);
+  },
+
+  currentCookieStoreId() {
+    const identity = Logic.currentIdentity();
+    return identity.cookieStoreId;
+  },
+
+  removeIdentity(userContextId) {
+    if (!userContextId) {
+      return Promise.reject("removeIdentity must be called with userContextId argument.");
+    }
+
+    return browser.runtime.sendMessage({
+      method: "deleteContainer",
+      message: {userContextId}
+    });
+  },
+
+  getAssignment(tab) {
+    return browser.runtime.sendMessage({
+      method: "getAssignment",
+      tabId: tab.id
+    });
+  },
+
+  getAssignmentObjectByContainer(userContextId) {
+    return browser.runtime.sendMessage({
+      method: "getAssignmentObjectByContainer",
+      message: {userContextId}
+    });
+  },
+
+  setOrRemoveAssignment(tabId, url, userContextId, value) {
+    return browser.runtime.sendMessage({
+      method: "setOrRemoveAssignment",
+      tabId,
+      url,
+      userContextId,
+      value
+    });
+  },
+
   generateIdentityName() {
     const defaultName = "Container #";
     const ids = [];
@@ -169,13 +332,16 @@ const Logic = {
 
 Logic.registerPanel(P_ONBOARDING_1, {
   panelSelector: ".onboarding-panel-1",
+  securityPanelSelector: ".security-onboarding-panel-1",
 
   // This method is called when the object is registered.
   initialize() {
     // Let's move to the next panel.
-    document.querySelector("#onboarding-start-button").addEventListener("click", () => {
-      localStorage.setItem("onboarded1", true);
-      Logic.showPanel(P_ONBOARDING_2);
+    [...document.querySelectorAll(".onboarding-start-button")].forEach(startElement => {
+      Logic.addEnterHandler(startElement, async function () {
+        await Logic.setOnboardingStage(1);
+        Logic.showPanel(P_ONBOARDING_2);
+      });
     });
   },
 
@@ -190,13 +356,16 @@ Logic.registerPanel(P_ONBOARDING_1, {
 
 Logic.registerPanel(P_ONBOARDING_2, {
   panelSelector: ".onboarding-panel-2",
+  securityPanelSelector: ".security-onboarding-panel-2",
 
   // This method is called when the object is registered.
   initialize() {
     // Let's move to the containers list panel.
-    document.querySelector("#onboarding-next-button").addEventListener("click", () => {
-      localStorage.setItem("onboarded2", true);
-      Logic.showPanel(P_ONBOARDING_3);
+    [...document.querySelectorAll(".onboarding-next-button")].forEach(nextElement => {
+      Logic.addEnterHandler(nextElement, async function () {
+        await Logic.setOnboardingStage(2);
+        Logic.showPanel(P_ONBOARDING_3);
+      });
     });
   },
 
@@ -211,12 +380,57 @@ Logic.registerPanel(P_ONBOARDING_2, {
 
 Logic.registerPanel(P_ONBOARDING_3, {
   panelSelector: ".onboarding-panel-3",
+  securityPanelSelector: ".security-onboarding-panel-3",
 
   // This method is called when the object is registered.
   initialize() {
     // Let's move to the containers list panel.
-    document.querySelector("#onboarding-done-button").addEventListener("click", () => {
-      localStorage.setItem("onboarded3", true);
+    [...document.querySelectorAll(".onboarding-almost-done-button")].forEach(almostElement => {
+      Logic.addEnterHandler(almostElement, async function () {
+        await Logic.setOnboardingStage(3);
+        Logic.showPanel(P_ONBOARDING_4);
+      });
+    });
+  },
+
+  // This method is called when the panel is shown.
+  prepare() {
+    return Promise.resolve(null);
+  },
+});
+
+// P_ONBOARDING_4: Fourth page for Onboarding.
+// ----------------------------------------------------------------------------
+
+Logic.registerPanel(P_ONBOARDING_4, {
+  panelSelector: ".onboarding-panel-4",
+
+  // This method is called when the object is registered.
+  initialize() {
+    // Let's move to the containers list panel.
+    Logic.addEnterHandler(document.querySelector("#onboarding-done-button"), async function () {
+      await Logic.setOnboardingStage(4);
+      Logic.showPanel(P_ONBOARDING_5);
+    });
+  },
+
+  // This method is called when the panel is shown.
+  prepare() {
+    return Promise.resolve(null);
+  },
+});
+
+// P_ONBOARDING_5: Fifth page for Onboarding: new tab long-press behavior
+// ----------------------------------------------------------------------------
+
+Logic.registerPanel(P_ONBOARDING_5, {
+  panelSelector: ".onboarding-panel-5",
+
+  // This method is called when the object is registered.
+  initialize() {
+    // Let's move to the containers list panel.
+    Logic.addEnterHandler(document.querySelector("#onboarding-longpress-button"), async function () {
+      await Logic.setOnboardingStage(5);
       Logic.showPanel(P_CONTAINERS_LIST);
     });
   },
@@ -234,34 +448,117 @@ Logic.registerPanel(P_CONTAINERS_LIST, {
   panelSelector: "#container-panel",
 
   // This method is called when the object is registered.
-  initialize() {
-    document.querySelector("#container-add-link").addEventListener("click", () => {
+  async initialize() {
+    Logic.addEnterHandler(document.querySelector("#container-add-link"), () => {
       Logic.showPanel(P_CONTAINER_EDIT, { name: Logic.generateIdentityName() });
     });
 
-    document.querySelector("#edit-containers-link").addEventListener("click", () => {
-      browser.runtime.sendMessage({
-        method: "sendTelemetryPayload",
-        event: "edit-containers"
-      });
+    Logic.addEnterHandler(document.querySelector("#edit-containers-link"), () => {
       Logic.showPanel(P_CONTAINERS_EDIT);
     });
 
-    document.querySelector("#sort-containers-link").addEventListener("click", () => {
-      browser.runtime.sendMessage({
-        method: "sortTabs"
-      }).then(() => {
+    Logic.addEnterHandler(document.querySelector("#sort-containers-link"), async function () {
+      try {
+        await browser.runtime.sendMessage({
+          method: "sortTabs"
+        });
         window.close();
-      }).catch(() => {
+      } catch (e) {
         window.close();
-      });
+      }
     });
+
+    document.addEventListener("keydown", (e) => {
+      const selectables = [...document.querySelectorAll("[tabindex='0'], [tabindex='-1']")];
+      const element = document.activeElement;
+      const index = selectables.indexOf(element) || 0;
+      function next() {
+        const nextElement = selectables[index + 1];
+        if (nextElement) {
+          nextElement.focus();
+        }
+      }
+      function previous() {
+        const previousElement = selectables[index - 1];
+        if (previousElement) {
+          previousElement.focus();
+        }
+      }
+      switch (e.keyCode) {
+      case 40:
+        next();
+        break;
+      case 38:
+        previous();
+        break;
+      }
+    });
+
+    // When the popup is open sometimes the tab will still be updating it's state
+    this.tabUpdateHandler = (tabId, changeInfo) => {
+      const propertiesToUpdate = ["title", "favIconUrl"];
+      const hasChanged = Object.keys(changeInfo).find((changeInfoKey) => {
+        if (propertiesToUpdate.includes(changeInfoKey)) {
+          return true;
+        }
+      });
+      if (hasChanged) {
+        this.prepareCurrentTabHeader();
+      }
+    };
+    browser.tabs.onUpdated.addListener(this.tabUpdateHandler);
+  },
+
+  unregister() {
+    browser.tabs.onUpdated.removeListener(this.tabUpdateHandler);
+  },
+
+  setupAssignmentCheckbox(siteSettings, currentUserContextId) {
+    const assignmentCheckboxElement = document.getElementById("container-page-assigned");
+    let checked = false;
+    if (siteSettings && Number(siteSettings.userContextId) === currentUserContextId) {
+      checked = true;
+    }
+    assignmentCheckboxElement.checked = checked;
+    let disabled = false;
+    if (siteSettings === false) {
+      disabled = true;
+    }
+    assignmentCheckboxElement.disabled = disabled;
+  },
+
+  async prepareCurrentTabHeader() {
+    const currentTab = await Logic.currentTab();
+    const currentTabElement = document.getElementById("current-tab");
+    const assignmentCheckboxElement = document.getElementById("container-page-assigned");
+    const currentTabUserContextId = Logic.userContextId(currentTab.cookieStoreId);
+    assignmentCheckboxElement.addEventListener("change", () => {
+      Logic.setOrRemoveAssignment(currentTab.id, currentTab.url, currentTabUserContextId, !assignmentCheckboxElement.checked);
+    });
+    currentTabElement.hidden = !currentTab;
+    this.setupAssignmentCheckbox(false, currentTabUserContextId);
+    if (currentTab) {
+      const identity = await Logic.identity(currentTab.cookieStoreId);
+      const siteSettings = await Logic.getAssignment(currentTab);
+      this.setupAssignmentCheckbox(siteSettings, currentTabUserContextId);
+      const currentPage = document.getElementById("current-page");
+      currentPage.innerHTML = escaped`<span class="page-title truncate-text">${currentTab.title}</span>`;
+      const favIconElement = Utils.createFavIconElement(currentTab.favIconUrl || "");
+      currentPage.prepend(favIconElement);
+
+      const currentContainer = document.getElementById("current-container");
+      currentContainer.innerText = identity.name;
+
+      currentContainer.setAttribute("data-identity-color", identity.color);
+    }
   },
 
   // This method is called when the panel is shown.
-  prepare() {
+  async prepare() {
     const fragment = document.createDocumentFragment();
 
+    this.prepareCurrentTabHeader();
+
     Logic.identities().forEach(identity => {
       const hasTabs = (identity.hasHiddenTabs || identity.hasOpenTabs);
       const tr = document.createElement("tr");
@@ -269,16 +566,20 @@ Logic.registerPanel(P_CONTAINERS_LIST, {
       const manage = document.createElement("td");
 
       tr.classList.add("container-panel-row");
+
       context.classList.add("userContext-wrapper", "open-newtab", "clickable");
       manage.classList.add("show-tabs", "pop-button");
+      manage.title = escaped`View ${identity.name} container`;
+      context.setAttribute("tabindex", "0");
+      context.title = escaped`Create ${identity.name} tab`;
       context.innerHTML = escaped`
         <div class="userContext-icon-wrapper open-newtab">
-          <div class="userContext-icon"
-            data-identity-icon="${identity.image}"
+          <div class="usercontext-icon"
+            data-identity-icon="${identity.icon}"
             data-identity-color="${identity.color}">
           </div>
         </div>
-        <div class="container-name"></div>`;
+        <div class="container-name truncate-text"></div>`;
       context.querySelector(".container-name").textContent = identity.name;
       manage.innerHTML = "<img src='/img/container-arrow.svg' class='show-tabs pop-button-image-small' />";
 
@@ -290,27 +591,40 @@ Logic.registerPanel(P_CONTAINERS_LIST, {
         tr.appendChild(manage);
       }
 
-      tr.addEventListener("click", e => {
-        if (e.target.matches(".open-newtab") || e.target.parentNode.matches(".open-newtab")) {
-          browser.runtime.sendMessage({
-            method: "openTab",
-            userContextId: identity.userContextId,
-            source: "pop-up"
-          }).then(() => {
+      Logic.addEnterHandler(tr, async function (e) {
+        if (e.target.matches(".open-newtab")
+            || e.target.parentNode.matches(".open-newtab")
+            || e.type === "keydown") {
+          try {
+            browser.tabs.create({
+              cookieStoreId: identity.cookieStoreId
+            });
             window.close();
-          }).catch(() => {
+          } catch (e) {
             window.close();
-          });
+          }
         } else if (hasTabs) {
           Logic.showPanel(P_CONTAINER_INFO, identity);
         }
       });
     });
 
-    const list = document.querySelector(".identities-list");
+    const list = document.querySelector(".identities-list tbody");
 
     list.innerHTML = "";
     list.appendChild(fragment);
+    /* Not sure why extensions require a focus for the doorhanger,
+       however it allows us to have a tabindex before the first selected item
+     */
+    const focusHandler = () => {
+      list.querySelector("tr .clickable").focus();
+      document.removeEventListener("focus", focusHandler);
+    };
+    document.addEventListener("focus", focusHandler);
+    /* If the user mousedown's first then remove the focus handler */
+    document.addEventListener("mousedown", () => {
+      document.removeEventListener("focus", focusHandler);
+    });
 
     return Promise.resolve();
   },
@@ -323,27 +637,30 @@ Logic.registerPanel(P_CONTAINER_INFO, {
   panelSelector: "#container-info-panel",
 
   // This method is called when the object is registered.
-  initialize() {
-    document.querySelector("#close-container-info-panel").addEventListener("click", () => {
+  async initialize() {
+    Logic.addEnterHandler(document.querySelector("#close-container-info-panel"), () => {
       Logic.showPreviousPanel();
     });
 
-    document.querySelector("#container-info-hideorshow").addEventListener("click", () => {
+    Logic.addEnterHandler(document.querySelector("#container-info-hideorshow"), async function () {
       const identity = Logic.currentIdentity();
-      browser.runtime.sendMessage({
-        method: identity.hasHiddenTabs ? "showTabs" : "hideTabs",
-        userContextId: identity.userContextId
-      }).then(() => {
+      try {
+        browser.runtime.sendMessage({
+          method: identity.hasHiddenTabs ? "showTabs" : "hideTabs",
+          windowId: browser.windows.WINDOW_ID_CURRENT,
+          cookieStoreId: Logic.currentCookieStoreId()
+        });
         window.close();
-      }).catch(() => {
+      } catch (e) {
         window.close();
-      });
+      }
     });
 
     // Check if the user has incompatible add-ons installed
-    browser.runtime.sendMessage({
-      method: "checkIncompatibleAddons"
-    }).then(incompatible => {
+    try {
+      const incompatible = await browser.runtime.sendMessage({
+        method: "checkIncompatibleAddons"
+      });
       const moveTabsEl = document.querySelector("#container-info-movetabs");
       if (incompatible) {
         const fragment = document.createDocumentFragment();
@@ -359,29 +676,29 @@ Logic.registerPanel(P_CONTAINER_INFO, {
 
         moveTabsEl.parentNode.insertBefore(fragment, moveTabsEl.nextSibling);
       } else {
-        moveTabsEl.addEventListener("click", () => {
-          return browser.runtime.sendMessage({
+        Logic.addEnterHandler(moveTabsEl, async function () {
+          await browser.runtime.sendMessage({
             method: "moveTabsToWindow",
-            userContextId: Logic.currentIdentity().userContextId,
-          }).then(() => {
-            window.close();
+            windowId: browser.windows.WINDOW_ID_CURRENT,
+            cookieStoreId: Logic.currentIdentity().cookieStoreId,
           });
+          window.close();
         });
       }
-    }).catch(() => {
+    } catch (e) {
       throw new Error("Could not check for incompatible add-ons.");
-    });
+    }
   },
 
   // This method is called when the panel is shown.
-  prepare() {
+  async prepare() {
     const identity = Logic.currentIdentity();
 
     // Populating the panel: name and icon
     document.getElementById("container-info-name").textContent = identity.name;
 
     const icon = document.getElementById("container-info-icon");
-    icon.setAttribute("data-identity-icon", identity.image);
+    icon.setAttribute("data-identity-icon", identity.icon);
     icon.setAttribute("data-identity-color", identity.color);
 
     // Show or not the has-tabs section.
@@ -402,10 +719,12 @@ Logic.registerPanel(P_CONTAINER_INFO, {
     }
 
     // Let's retrieve the list of tabs.
-    return browser.runtime.sendMessage({
+    const tabs = await browser.runtime.sendMessage({
       method: "getTabs",
-      userContextId: identity.userContextId,
-    }).then(this.buildInfoTable);
+      windowId: browser.windows.WINDOW_ID_CURRENT,
+      cookieStoreId: Logic.currentIdentity().cookieStoreId
+    });
+    return this.buildInfoTable(tabs);
   },
 
   buildInfoTable(tabs) {
@@ -416,21 +735,16 @@ Logic.registerPanel(P_CONTAINER_INFO, {
       fragment.appendChild(tr);
       tr.classList.add("container-info-tab-row");
       tr.innerHTML = escaped`
-        <td><img class="icon" src="${tab.favicon}" /></td>
-        <td class="container-info-tab-title">${tab.title}</td>`;
+        <td></td>
+        <td class="container-info-tab-title truncate-text" title="${tab.url}" >${tab.title}</td>`;
+      tr.querySelector("td").appendChild(Utils.createFavIconElement(tab.favIconUrl));
 
       // On click, we activate this tab. But only if this tab is active.
-      if (tab.active) {
+      if (!tab.hiddenState) {
         tr.classList.add("clickable");
-        tr.addEventListener("click", () => {
-          browser.runtime.sendMessage({
-            method: "showTab",
-            tabId: tab.id,
-          }).then(() => {
-            window.close();
-          }).catch(() => {
-            window.close();
-          });
+        Logic.addEnterHandler(tr, async function () {
+          await browser.tabs.update(tab.id, {active: true});
+          window.close();
         });
       }
     }
@@ -447,7 +761,7 @@ Logic.registerPanel(P_CONTAINERS_EDIT, {
 
   // This method is called when the object is registered.
   initialize() {
-    document.querySelector("#exit-edit-mode-link").addEventListener("click", () => {
+    Logic.addEnterHandler(document.querySelector("#exit-edit-mode-link"), () => {
       Logic.showPanel(P_CONTAINERS_LIST);
     });
   },
@@ -462,30 +776,30 @@ Logic.registerPanel(P_CONTAINERS_EDIT, {
       tr.innerHTML = escaped`
         <td class="userContext-wrapper">
           <div class="userContext-icon-wrapper">
-            <div class="userContext-icon"
-              data-identity-icon="${identity.image}"
+            <div class="usercontext-icon"
+              data-identity-icon="${identity.icon}"
               data-identity-color="${identity.color}">
             </div>
           </div>
-          <div class="container-name"></div>
+          <div class="container-name truncate-text"></div>
         </td>
         <td class="edit-container pop-button edit-container-icon">
           <img
             src="/img/container-edit.svg"
             class="pop-button-image" />
         </td>
-        <td class="remove-container pop-button delete-container-icon" >
+        <td class="remove-container pop-button delete-container-icon">
           <img
             class="pop-button-image"
             src="/img/container-delete.svg"
           />
         </td>`;
       tr.querySelector(".container-name").textContent = identity.name;
-      tr.querySelector(".edit-container .pop-button-image").setAttribute("title", `Edit ${identity.name} container`);
-      tr.querySelector(".remove-container .pop-button-image").setAttribute("title", `Edit ${identity.name} container`);
+      tr.querySelector(".edit-container").setAttribute("title", `Edit ${identity.name} container`);
+      tr.querySelector(".remove-container").setAttribute("title", `Remove ${identity.name} container`);
 
 
-      tr.addEventListener("click", e => {
+      Logic.addEnterHandler(tr, e => {
         if (e.target.matches(".edit-container-icon") || e.target.parentNode.matches(".edit-container-icon")) {
           Logic.showPanel(P_CONTAINER_EDIT, identity);
         } else if (e.target.matches(".delete-container-icon") || e.target.parentNode.matches(".delete-container-icon")) {
@@ -513,37 +827,96 @@ Logic.registerPanel(P_CONTAINER_EDIT, {
   initialize() {
     this.initializeRadioButtons();
 
-    document.querySelector("#edit-container-panel-back-arrow").addEventListener("click", () => {
-      Logic.showPreviousPanel();
+    Logic.addEnterHandler(document.querySelector("#edit-container-panel-back-arrow"), () => {
+      const formValues = new FormData(this._editForm);
+      if (formValues.get("container-id") !== NEW_CONTAINER_ID) {
+        this._submitForm();
+      } else {
+        Logic.showPreviousPanel();
+      }
     });
 
-    document.querySelector("#edit-container-cancel-link").addEventListener("click", () => {
+    Logic.addEnterHandler(document.querySelector("#edit-container-cancel-link"), () => {
       Logic.showPreviousPanel();
     });
 
     this._editForm = document.getElementById("edit-container-panel-form");
     const editLink = document.querySelector("#edit-container-ok-link");
-    editLink.addEventListener("click", this._submitForm.bind(this));
-    editLink.addEventListener("submit", this._submitForm.bind(this));
-    this._editForm.addEventListener("submit", this._submitForm.bind(this));
+    Logic.addEnterHandler(editLink, () => {
+      this._submitForm();
+    });
+    editLink.addEventListener("submit", () => {
+      this._submitForm();
+    });
+    this._editForm.addEventListener("submit", () => {
+      this._submitForm();
+    });
+
+
   },
 
-  _submitForm() {
-    const identity = Logic.currentIdentity();
+  async _submitForm() {
     const formValues = new FormData(this._editForm);
-    browser.runtime.sendMessage({
-      method: identity.userContextId ? "updateIdentity" : "createIdentity",
-      userContextId: identity.userContextId || 0,
-      name: document.getElementById("edit-container-panel-name-input").value || Logic.generateIdentityName(),
-      icon: formValues.get("container-icon") || DEFAULT_ICON,
-      color: formValues.get("container-color") || DEFAULT_COLOR,
-    }).then(() => {
-      return Logic.refreshIdentities();
-    }).then(() => {
+    try {
+      await browser.runtime.sendMessage({
+        method: "createOrUpdateContainer",
+        message: {
+          userContextId: formValues.get("container-id") || NEW_CONTAINER_ID,
+          params: {
+            name: document.getElementById("edit-container-panel-name-input").value || Logic.generateIdentityName(),
+            icon: formValues.get("container-icon") || DEFAULT_ICON,
+            color: formValues.get("container-color") || DEFAULT_COLOR,
+          }
+        }
+      });
+      await Logic.refreshIdentities();
       Logic.showPreviousPanel();
-    }).catch(() => {
+    } catch (e) {
       Logic.showPanel(P_CONTAINERS_LIST);
-    });
+    }
+  },
+
+  showAssignedContainers(assignments) {
+    const assignmentPanel = document.getElementById("edit-sites-assigned");
+    const assignmentKeys = Object.keys(assignments);
+    assignmentPanel.hidden = !(assignmentKeys.length > 0);
+    if (assignments) {
+      const tableElement = assignmentPanel.querySelector(".assigned-sites-list");
+      /* Remove previous assignment list,
+         after removing one we rerender the list */
+      while (tableElement.firstChild) {
+        tableElement.firstChild.remove();
+      }
+      assignmentKeys.forEach((siteKey) => {
+        const site = assignments[siteKey];
+        const trElement = document.createElement("div");
+        /* As we don't have the full or correct path the best we can assume is the path is HTTPS and then replace with a broken icon later if it doesn't load.
+           This is pending a better solution for favicons from web extensions */
+        const assumedUrl = `https://${site.hostname}`;
+        trElement.innerHTML = escaped`
+        <img class="icon" src="${assumedUrl}/favicon.ico">
+        <div title="${site.hostname}" class="truncate-text hostname">
+          ${site.hostname}
+        </div>
+        <img
+          class="pop-button-image delete-assignment"
+          src="/img/container-delete.svg"
+        />`;
+        const deleteButton = trElement.querySelector(".delete-assignment");
+        const that = this;
+        Logic.addEnterHandler(deleteButton, async function () {
+          const userContextId = Logic.currentUserContextId();
+          // Lets show the message to the current tab
+          // TODO remove then when firefox supports arrow fn async
+          const currentTab = await Logic.currentTab();
+          Logic.setOrRemoveAssignment(currentTab.id, assumedUrl, userContextId, true);
+          delete assignments[siteKey];
+          that.showAssignedContainers(assignments);
+        });
+        trElement.classList.add("container-info-tab-row", "clickable");
+        tableElement.appendChild(trElement);
+      });
+    }
   },
 
   initializeRadioButtons() {
@@ -554,8 +927,9 @@ Logic.registerPanel(P_CONTAINER_EDIT, {
     const colors = ["blue", "turquoise", "green", "yellow", "orange", "red", "pink", "purple" ];
     const colorRadioFieldset = document.getElementById("edit-container-panel-choose-color");
     colors.forEach((containerColor) => {
-      const templateInstance = document.createElement("span");
-      // eslint-disable-next-line no-unescaped/enforce
+      const templateInstance = document.createElement("div");
+      templateInstance.classList.add("radio-container");
+      // eslint-disable-next-line no-unsanitized/property
       templateInstance.innerHTML = colorRadioTemplate(containerColor);
       colorRadioFieldset.appendChild(templateInstance);
     });
@@ -567,22 +941,30 @@ Logic.registerPanel(P_CONTAINER_EDIT, {
     const icons = ["fingerprint", "briefcase", "dollar", "cart", "vacation", "gift", "food", "fruit", "pet", "tree", "chill", "circle"];
     const iconRadioFieldset = document.getElementById("edit-container-panel-choose-icon");
     icons.forEach((containerIcon) => {
-      const templateInstance = document.createElement("span");
-      // eslint-disable-next-line no-unescaped/enforce
+      const templateInstance = document.createElement("div");
+      templateInstance.classList.add("radio-container");
+      // eslint-disable-next-line no-unsanitized/property
       templateInstance.innerHTML = iconRadioTemplate(containerIcon);
       iconRadioFieldset.appendChild(templateInstance);
     });
   },
 
   // This method is called when the panel is shown.
-  prepare() {
+  async prepare() {
     const identity = Logic.currentIdentity();
+
+    const userContextId = Logic.currentUserContextId();
+    const assignments = await Logic.getAssignmentObjectByContainer(userContextId);
+    this.showAssignedContainers(assignments);
+    document.querySelector("#edit-container-panel .panel-footer").hidden = !!userContextId;
+
     document.querySelector("#edit-container-panel-name-input").value = identity.name || "";
+    document.querySelector("#edit-container-panel-usercontext-input").value = userContextId || NEW_CONTAINER_ID;
     [...document.querySelectorAll("[name='container-color']")].forEach(colorInput => {
       colorInput.checked = colorInput.value === identity.color;
     });
     [...document.querySelectorAll("[name='container-icon']")].forEach(iconInput => {
-      iconInput.checked = iconInput.value === identity.image;
+      iconInput.checked = iconInput.value === identity.icon;
     });
 
     return Promise.resolve(null);
@@ -598,21 +980,23 @@ Logic.registerPanel(P_CONTAINER_DELETE, {
 
   // This method is called when the object is registered.
   initialize() {
-    document.querySelector("#delete-container-cancel-link").addEventListener("click", () => {
+    Logic.addEnterHandler(document.querySelector("#delete-container-cancel-link"), () => {
       Logic.showPreviousPanel();
     });
 
-    document.querySelector("#delete-container-ok-link").addEventListener("click", () => {
-      browser.runtime.sendMessage({
-        method: "removeIdentity",
-        userContextId: Logic.currentIdentity().userContextId,
-      }).then(() => {
-        return Logic.refreshIdentities();
-      }).then(() => {
+    Logic.addEnterHandler(document.querySelector("#delete-container-ok-link"), async function () {
+      /* This promise wont resolve if the last tab was removed from the window.
+          as the message async callback stops listening, this isn't an issue for us however it might be in future
+          if you want to do anything post delete do it in the background script.
+          Browser console currently warns about not listening also.
+      */
+      try {
+        await Logic.removeIdentity(Logic.userContextId(Logic.currentIdentity().cookieStoreId));
+        await Logic.refreshIdentities();
         Logic.showPreviousPanel();
-      }).catch(() => {
+      } catch(e) {
         Logic.showPanel(P_CONTAINERS_LIST);
-      });
+      }
     });
   },
 
@@ -624,7 +1008,7 @@ Logic.registerPanel(P_CONTAINER_DELETE, {
     document.getElementById("delete-container-name").textContent = identity.name;
 
     const icon = document.getElementById("delete-container-icon");
-    icon.setAttribute("data-identity-icon", identity.image);
+    icon.setAttribute("data-identity-icon", identity.icon);
     icon.setAttribute("data-identity-color", identity.color);
 
     return Promise.resolve(null);

webextension/js/utils.js

@@ -0,0 +1,23 @@
+const DEFAULT_FAVICON = "moz-icon://goat?size=16";
+
+// TODO use export here instead of globals
+window.Utils = {
+
+  createFavIconElement(url) {
+    const imageElement = document.createElement("img");
+    imageElement.classList.add("icon", "offpage");
+    imageElement.src = url;
+    const loadListener = (e) => {
+      e.target.classList.remove("offpage");
+      e.target.removeEventListener("load", loadListener);
+      e.target.removeEventListener("error", errorListener);
+    };
+    const errorListener = (e) => {
+      e.target.src = DEFAULT_FAVICON;
+    };
+    imageElement.addEventListener("error", errorListener);
+    imageElement.addEventListener("load", loadListener);
+    return imageElement;
+  }
+
+};

webextension/manifest.json

@@ -1,9 +1,9 @@
 {
   "manifest_version": 2,
-  "name": "Containers Experiment",
-  "version": "2.2.0",
+  "name": "Firefox Multi-Account Containers",
+  "version": "4.0.3",
 
-  "description": "Containers works by isolating cookie jars using separate origin-attributes defined visually by colored ‘Container Tabs’. This add-on is a modified version of the containers feature for Firefox Test Pilot.",
+  "description": "Multi-Account Containers helps you keep all the parts of your online life contained in different tabs. Custom labels and color-coded tabs help keep different activities — like online shopping, travel planning, or checking work email — separate.",
   "icons": {
     "48": "img/container-site-d-48.png",
     "96": "img/container-site-d-96.png"
@@ -11,8 +11,7 @@
 
   "applications": {
     "gecko": {
-      "strict_min_version": "51.0",
-      "update_url": "https://testpilot.firefox.com/files/@testpilot-containers/updates.json"
+      "strict_min_version": "53.0"
     }
   },
 
@@ -23,26 +22,46 @@
     "activeTab",
     "cookies",
     "contextMenus",
+    "contextualIdentities",
     "history",
     "idle",
-    "notifications",
     "storage",
     "tabs",
     "webRequestBlocking",
     "webRequest"
   ],
 
+  "commands": {
+    "_execute_browser_action": {
+      "suggested_key": {
+        "default": "Ctrl+Period",
+        "mac": "MacCtrl+Period"
+      },
+      "description": "Open containers panel"
+    }
+  },
+
   "browser_action": {
     "browser_style": true,
-    "default_icon": {
-      "16": "img/container-site-d-24.png",
-      "32": "img/container-site-d-48.png"
-    },
-    "default_title": "Containers",
+    "default_icon": "img/container-site.svg",
+    "default_title": "Multi-Account Containers",
     "default_popup": "popup.html"
   },
 
   "background": {
-    "scripts": ["background.js"]
-  }
+    "page": "js/background/index.html"
+  },
+
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": ["js/content-script.js"],
+      "css": ["css/content.css"],
+      "run_at": "document_start"
+    }
+  ],
+
+  "web_accessible_resources": [
+    "/img/container-site-d-24.png"
+  ]
 }

webextension/popup.html

@@ -1,57 +1,104 @@
 <html>
 <head>
   <meta http-equiv="content-type" content="text/html; charset=utf-8">
-  <title>Containers browserAction Popup</title>
+  <title>Multi-Account Containers</title>
   <link rel="stylesheet" href="/css/popup.css">
+
 </head>
 <body>
 
-  <div class="hide panel onboarding onboarding-panel-1" id="onboarding-panel-1">
+  <div class="hide panel onboarding onboarding-panel-1">
     <img class="onboarding-img" alt="Container Tabs Overview" src="/img/onboarding-1.png" />
     <h3 class="onboarding-title">A better way to manage all the things you do online</h3>
     <p>
       Use containers to organize tasks, manage accounts, and keep your focus where you want it.
     </p>
-    <a href="#" id="onboarding-start-button" class="onboarding-button">Get Started</a>
+    <a href="#" class="onboarding-button onboarding-start-button">Get Started</a>
   </div>
 
+  <div class="hide panel onboarding security-onboarding-panel-1">
+    <img class="onboarding-img" alt="Container Tabs Overview" src="/img/onboarding-1.png" />
+    <h3 class="onboarding-title">A simple and secure way to manage your online life</h3>
+    <p>
+      Use containers to organize tasks, manage accounts, and store sensitive data.
+    </p>
+    <a href="#" class="onboarding-button onboarding-start-button">Get Started</a>
+  </div>
 
-  <div class="panel onboarding onboarding-panel-2 hide" id="onboarding-panel-2">
+  <div class="panel onboarding onboarding-panel-2 hide">
     <img class="onboarding-img" alt="How Containers Work" src="/img/onboarding-2.png" />
     <h3 class="onboarding-title">Put containers to work for you.</h3>
     <p>Features like color-coding and separate container tabs help you find things easily, focus your attention, and minimize distractions.</p>
-    <a href="#" id="onboarding-next-button" class="onboarding-button">Next</a>
+    <a href="#" class="onboarding-button onboarding-next-button">Next</a>
   </div>
 
-  <div class="panel onboarding onboarding-panel-3 hide" id="onboarding-panel-3">
+  <div class="panel onboarding security-onboarding-panel-2 hide">
+    <img class="onboarding-img" alt="How Containers Work" src="/img/onboarding-2.png" />
+    <h3 class="onboarding-title">Put containers to work for you.</h3>
+    <p>Color-coding helps you categorize your online life, find things easily, and minimize distractions.</p>
+    <a href="#" class="onboarding-button onboarding-next-button">Next</a>
+  </div>
+
+  <div class="panel onboarding onboarding-panel-3 hide">
     <img class="onboarding-img" alt="How Containers Work" src="/img/onboarding-3.png" />
     <h3 class="onboarding-title">A place for everything, and everything in its place.</h3>
     <p>Start with the containers we've created, or create your own.</p>
-    <a href="#" id="onboarding-done-button" class="onboarding-button">Done</a>
+    <a href="#" class="onboarding-button onboarding-almost-done-button">Next</a>
+  </div>
+
+  <div class="panel onboarding security-onboarding-panel-3 hide">
+    <img class="onboarding-img" alt="How Containers Work" src="/img/onboarding-3-security.png" />
+    <h3 class="onboarding-title">Set boundaries for your browsing.</h3>
+    <p>Cookies are stored within a container, so you can segment sensitive data and browsing history to stay organized and to limit the impact of online trackers.</p>
+    <a href="#" class="onboarding-button onboarding-almost-done-button">Next</a>
+  </div>
+
+  <div class="panel onboarding onboarding-panel-4 hide" id="onboarding-panel-4">
+    <img class="onboarding-img" alt="How to assign sites to containers" src="/img/onboarding-4.png" />
+    <h3 class="onboarding-title">Always open sites in the containers you want.</h3>
+    <p>Right-click inside a container tab to assign the site to always open in the container.</p>
+    <a href="#" id="onboarding-done-button" class="onboarding-button">Next</a>
+  </div>
+
+  <div class="panel onboarding onboarding-panel-5 hide" id="onboarding-panel-5">
+    <img class="onboarding-img" alt="Long-press the New Tab button to create a new container tab." src="/img/onboarding-3.png" />
+    <h3 class="onboarding-title">Container tabs when you need them.</h3>
+    <p>Long-press the New Tab button to create a new container tab.</p>
+    <a href="#" id="onboarding-longpress-button" class="onboarding-button">Done</a>
   </div>
 
   <div class="panel container-panel hide" id="container-panel">
-    <div class="panel-header">
-      <h3 class="panel-header-text">Containers</h3>
-      <a class="pop-button" id="sort-containers-link"><img class="pop-button-image" alt="Sort Containers" title="Sort Containers" src="/img/container-sort.svg"></a>
+    <div id="current-tab">
+      <h3>Current Tab</h3>
+      <div id="current-page"></div>
+      <label for="container-page-assigned">
+        <input type="checkbox" id="container-page-assigned" />
+        <span class="truncate-text">
+          Always open in
+          <span id="current-container"></span>
+        </span>
+      </label>
     </div>
-    <div class="scrollable panel-content">
-      <table>
-        <tbody class="identities-list"></tbody>
+    <div class="container-panel-controls">
+      <a href="#" class="action-link" id="sort-containers-link" title="Sort tabs into container order">Sort Tabs</a>
+    </div>
+    <div class="scrollable panel-content" tabindex="-1">
+      <table class="identities-list">
+        <tbody></tbody>
       </table>
     </div>
     <div class="panel-footer edit-identities">
       <div class="edit-containers-text panel-footer-secondary">
-        <a id="edit-containers-link">Edit Containers</a>
+        <a href="#" tabindex="0" id="edit-containers-link">Edit Containers</a>
       </div>
-      <a class="add-container-link pop-button" id="container-add-link">
-        <img class="pop-button-image-small icon" alt="Create new container icon" title="Create new container" src="/img/container-add.svg" />
+      <a href="#" tabindex="0" class="add-container-link pop-button" id="container-add-link" title="Create new container">
+        <img class="pop-button-image-small icon" alt="Create new container icon" src="/img/container-add.svg" />
       </a>
     </div>
   </div>
 
 
-  <div class="hide panel container-info-panel" id="container-info-panel">
+  <div class="hide panel container-info-panel" id="container-info-panel" tabindex="-1">
     <div class="columns">
       <div class="panel-back-arrow" id="close-container-info-panel">
         <img alt="Panel Back Arrow" src="/img/container-arrow.svg" class="back-arrow-img" />
@@ -59,7 +106,7 @@
       <div class="column-panel-content">
         <div class="panel-header container-info-panel-header">
           <span class="usercontext-icon" id="container-info-icon"></span>
-          <h3 id="container-info-name" class="panel-header-text container-name"></h3>
+          <h3 id="container-info-name" class="panel-header-text container-name truncate-text"></h3>
         </div>
         <div class="select-row clickable container-info-panel-hide container-info-has-tabs" id="container-info-hideorshow">
           <img id="container-info-hideorshow-icon" alt="Hide Container icon" src="/img/container-hide.svg" class="icon container-info-panel-hideorshow-icon"/>
@@ -85,7 +132,7 @@
       </table>
     </div>
     <div class="panel-footer edit-containers-panel-footer">
-      <a id="exit-edit-mode-link" class="exit-edit-mode-link edit-containers-exit-text">Exit Edit Mode</a>
+      <a href="#" id="exit-edit-mode-link" class="exit-edit-mode-link edit-containers-exit-text">Exit Edit Mode</a>
     </div>
   </div>
 
@@ -97,19 +144,25 @@
       </div>
       <div class="column-panel-content">
         <form id="edit-container-panel-form">
+          <input type="hidden" name="container-id" id="edit-container-panel-usercontext-input" />
           <fieldset>
             <legend>Name</legend>
             <input type="text" name="container-name" id="edit-container-panel-name-input" maxlength="25"/>
           </fieldset>
-          <fieldset id="edit-container-panel-choose-color">
+          <fieldset id="edit-container-panel-choose-color" class="radio-choice">
             <legend>Choose a color</legend>
           </fieldset>
-          <fieldset id="edit-container-panel-choose-icon">
+          <fieldset id="edit-container-panel-choose-icon" class="radio-choice">
             <legend>Choose an icon</legend>
           </fieldset>
         </form>
+        <div id="edit-sites-assigned" class="scrollable" hidden>
+          <h3>Sites assigned to this container</h3>
+          <div class="assigned-sites-list">
+          </div>
+        </div>
         <div class="panel-footer">
-          <a class="button secondary expanded footer-button cancel-button" id="edit-container-cancel-link">Cancel</a>
+          <a href="#" class="button secondary expanded footer-button cancel-button" id="edit-container-cancel-link">Cancel</a>
           <a class="button primary expanded footer-button" id="edit-container-ok-link">OK</a>
         </div>
       </div>
@@ -126,12 +179,12 @@
       <p>If you remove this container now, <span id="delete-container-tab-count"></span> container tabs will be closed. Are you sure you want to remove this Container?</p>
     </div>
     <div class="panel-footer">
-      <a class="button expanded secondary footer-button cancel-button" id="delete-container-cancel-link">Cancel</a>
-      <a class="button expanded primary footer-button" id="delete-container-ok-link">OK</a>
+      <a href="#" class="button expanded secondary footer-button cancel-button" id="delete-container-cancel-link">Cancel</a>
+      <a href="#" class="button expanded primary footer-button" id="delete-container-ok-link">OK</a>
     </div>
   </div>
 
-
+  <script src="js/utils.js"></script>
   <script src="js/popup.js"></script>
 </body>
 </html>