67b3780d38
Originally, the polyfill created a Proxy with the original API object as the target. This was changed to `Object.create(chrome)` because not doing so would prevent the `browser.devtools` API from working because the devtools API object is assigned as a read-only & non-configurable property (#57). However, that action itself caused a new bug: Whenever an API object is dereferenced via the `browser` namespace, the original API is no longer available in the `chrome` namespace, and trying to access the API through `chrome` returns `undefined` plus the "Previous API instantiation failed" warning (#58). This is because Chrome lazily initializes fields in the `chrome` API, but on the object from which the property is accessed, while the polyfill accessed the property through an object with the prototype set to `chrome` instead of directly via chrome. To fix that, `Object.create(chrome)` was replaced with `Object.assign({}, chrome)`. This fixes both of the previous issues because 1) It is still a new object. 2) All lazily initialized fields are explicitly initialized. This fix created a new issue: In Chrome some APIs cannot be used even though they are visible in the API (e.g. `chrome.clipboard`), so calling `Object.assign({}, chrome)` causes an error to be printed to the console (#70). To solve this, I use `Object.create(chrome)` again as a proxy target, but dereference the API via the original target (`chrome`) to not regress on #58. Besides fixing the bug, this also reduces the performance impact of the API because all API fields are lazily initialized again, instead of upon start-up. This fixes #70. |
||
|---|---|---|
| src | ||
| test | ||
| .eslintrc | ||
| .gitignore | ||
| .travis.yml | ||
| Gruntfile.js | ||
| LICENSE | ||
| README.md | ||
| api-metadata.json | ||
| package.json | ||
README.md
WebExtension browser API Polyfill 
This library allows extensions written for the Promise-based WebExtension/BrowserExt API being standardized by the W3 Browser Extensions group to be used without modification in Google Chrome.
Table of contents
Building
To build, assuming you're already installed node >= 6 and npm, simply run:
npm install
npm run build
npm run test
This will install all the npm dependencies and build both non-minified and minified versions
of the final library, and output them to dist/browser-polyfill.js and dist/browser-polyfill.min.js,
respectively, and finally executes the unit tests on the generated dist files.
Basic Setup
In order to use the polyfill, it must be loaded into any context where
browser APIs are accessed. The most common cases are background and
content scripts, which can be specified in manifest.json:
{
// ...
"background": {
"scripts": [
"browser-polyfill.js",
"background.js"
]
},
"content_scripts": [{
// ...
"js": [
"browser-polyfill.js",
"content.js"
]
}]
}
For HTML documents, such as browserAction popups, or tab pages, it must be
included more explicitly:
<!DOCTYPE html>
<html>
<head>
<script type="application/javascript" src="browser-polyfill.js"></script>
<script type="application/javascript" src="popup.js"></script>
</head>
<!-- ... -->
</html>
And for dynamically-injected content scripts loaded by tabs.executeScript,
it must be injected by a separate executeScript call, unless it has
already been loaded via a content_scripts declaration in
manifest.json:
browser.tabs.executeScript({file: "browser-polyfill.js"});
browser.tabs.executeScript({file: "content.js"}).then(result => {
// ...
});
Using the Promise-based APIs
The Promise-based APIs in the browser namespace work, for the most part,
very similarly to the callback-based APIs in Chrome's chrome namespace.
The major differences are:
-
Rather than receiving a callback argument, every async function returns a
Promiseobject, which resolves or rejects when the operation completes. -
Rather than checking the
chrome.runtime.lastErrorproperty from every callback, code which needs to explicitly deal with errors registers a separate Promise rejection handler. -
Rather than receiving a
sendResponsecallback to send a response,onMessagelisteners simply return a Promise whose resolution value is used as a reply. -
Rather than nesting callbacks when a sequence of operations depend on each other, Promise chaining is generally used instead.
-
For users of an ES7 transpiler, such as Babel, the resulting Promises are generally used with
asyncandawait, rather than dealt with directly.
Examples
The following code will retrieve a list of URLs patterns from the storage
API, retrieve a list of tabs which match any of them, reload each of those
tabs, and notify the user that is has been done:
browser.storage.get("urls").then(({urls}) => {
return browser.tabs.query({url: urls});
}).then(tabs => {
return Promise.all(
Array.from(tabs, tab => browser.tabs.reload(tab.id)));
);
}).then(() => {
return browser.notifications.create({
type: "basic",
iconUrl: "icon.png",
title: "Tabs reloaded",
message: "Your tabs have been reloaded",
});
}).catch(error => {
console.error(`An error occurred while reloading tabs: ${error.message}`);
});
Or, using an async function:
async function reloadTabs() {
try {
let {urls} = await browser.storage.get("urls");
let tabs = await browser.tabs.query({url: urls});
await Promise.all(
Array.from(tabs, tab => browser.tabs.reload(tab.id)));
);
await browser.notifications.create({
type: "basic",
iconUrl: "icon.png",
title: "Tabs reloaded",
message: "Your tabs have been reloaded",
});
} catch (error) {
console.error(`An error occurred while reloading tabs: ${error.message}`);
}
}
It's also possible to use Promises effectively using two-way messaging. Communication between a background page and a tab content script, for example, looks something like this from the background page side:
browser.tabs.sendMessage("get-ids").then(results => {
processResults(results);
});
And like this from the content script:
browser.runtime.onMessage.addListener(msg => {
if (msg == "get-ids") {
return browser.storage.get("idPattern").then(({idPattern}) => {
return Array.from(document.querySelectorAll(idPattern),
elem => elem.textContent);
});
}
});
or:
browser.runtime.onMessage.addListener(async function(msg) {
if (msg == "get-ids") {
let {idPattern} = await browser.storage.get("idPattern");
return Array.from(document.querySelectorAll(idPattern),
elem => elem.textContent);
}
});
Or vice versa.